


import gc
import unittest

from transformers import MODEL_FOR_MASKED_LM_MAPPING, TF_MODEL_FOR_MASKED_LM_MAPPING, FillMaskPipeline, pipeline
from transformers.pipelines import PipelineException
from transformers.testing_utils import (
    is_pipeline_test,
    is_torch_available,
    nested_simplify,
    require_tf,
    require_torch,
    require_torch_gpu,
    slow,
)

from .test_pipelines_common import ANY





@is_pipeline_test
class  lowerCAmelCase__(    unittest.TestCase						):






    '''simple docstring'''





    A_  :     List[Any]			= MODEL_FOR_MASKED_LM_MAPPING
    A_  :     Optional[int]			= TF_MODEL_FOR_MASKED_LM_MAPPING





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





       '''simple docstring'''
       super().tearDown()
       # clean-up as much as possible GPU memory occupied by PyTorch
       gc.collect()
       if is_torch_available():
          import torch

          torch.cuda.empty_cache()





    @require_tf
    def 					_lowerCamelCase (	self				:   Dict	):





       '''simple docstring'''
       UpperCAmelCase_							:      Tuple						=   pipeline(task='''fill-mask'''       ,   model='''sshleifer/tiny-distilroberta-base'''       ,   top_k=2       ,   framework='''tf'''	)
       UpperCAmelCase_							:      str						=   unmasker('''My name is <mask>'''	)
       self.assertEqual(
           nested_simplify(__snake_case       ,   decimals=6	)       ,   [
               {'''sequence''': '''My name is grouped''', '''score''': 2.1E-05, '''token''': 38_015, '''token_str''': ''' grouped'''},
               {'''sequence''': '''My name is accuser''', '''score''': 2.1E-05, '''token''': 25_506, '''token_str''': ''' accuser'''},
           ]       ,   )

       UpperCAmelCase_							:      Optional[int]						=   unmasker('''The largest city in France is <mask>'''	)
       self.assertEqual(
           nested_simplify(__snake_case       ,   decimals=6	)       ,   [
               {
                   '''sequence''': '''The largest city in France is grouped''',
                   '''score''': 2.1E-05,
                   '''token''': 38_015,
                   '''token_str''': ''' grouped''',
               },
               {
                   '''sequence''': '''The largest city in France is accuser''',
                   '''score''': 2.1E-05,
                   '''token''': 25_506,
                   '''token_str''': ''' accuser''',
               },
           ]       ,   )

       UpperCAmelCase_							:      str						=   unmasker('''My name is <mask>'''       ,   targets=[''' Patrick''', ''' Clara''', ''' Teven''']       ,   top_k=3	)
       self.assertEqual(
           nested_simplify(__snake_case       ,   decimals=6	)       ,   [
               {'''sequence''': '''My name is Clara''', '''score''': 2E-05, '''token''': 13_606, '''token_str''': ''' Clara'''},
               {'''sequence''': '''My name is Patrick''', '''score''': 2E-05, '''token''': 3_499, '''token_str''': ''' Patrick'''},
               {'''sequence''': '''My name is Te''', '''score''': 1.9E-05, '''token''': 2_941, '''token_str''': ''' Te'''},
           ]       ,   )





    @require_torch
    def 					_lowerCamelCase (	self				:   Dict	):





       '''simple docstring'''
       UpperCAmelCase_							:      Dict						=   pipeline(task='''fill-mask'''       ,   model='''sshleifer/tiny-distilroberta-base'''       ,   top_k=2       ,   framework='''pt'''	)

       UpperCAmelCase_							:      Dict						=   unmasker('''My name is <mask>'''	)
       self.assertEqual(
           nested_simplify(__snake_case       ,   decimals=6	)       ,   [
               {'''sequence''': '''My name is Maul''', '''score''': 2.2E-05, '''token''': 35_676, '''token_str''': ''' Maul'''},
               {'''sequence''': '''My name isELS''', '''score''': 2.2E-05, '''token''': 16_416, '''token_str''': '''ELS'''},
           ]       ,   )

       UpperCAmelCase_							:      str						=   unmasker('''The largest city in France is <mask>'''	)
       self.assertEqual(
           nested_simplify(__snake_case       ,   decimals=6	)       ,   [
               {
                   '''sequence''': '''The largest city in France is Maul''',
                   '''score''': 2.2E-05,
                   '''token''': 35_676,
                   '''token_str''': ''' Maul''',
               },
               {'''sequence''': '''The largest city in France isELS''', '''score''': 2.2E-05, '''token''': 16_416, '''token_str''': '''ELS'''},
           ]       ,   )

       UpperCAmelCase_							:      Union[str, Any]						=   unmasker('''My name is <mask>'''       ,   targets=[''' Patrick''', ''' Clara''', ''' Teven''']       ,   top_k=3	)
       self.assertEqual(
           nested_simplify(__snake_case       ,   decimals=6	)       ,   [
               {'''sequence''': '''My name is Patrick''', '''score''': 2.1E-05, '''token''': 3_499, '''token_str''': ''' Patrick'''},
               {'''sequence''': '''My name is Te''', '''score''': 2E-05, '''token''': 2_941, '''token_str''': ''' Te'''},
               {'''sequence''': '''My name is Clara''', '''score''': 2E-05, '''token''': 13_606, '''token_str''': ''' Clara'''},
           ]       ,   )

       UpperCAmelCase_							:      Any						=   unmasker('''My name is <mask> <mask>'''       ,   top_k=2	)

       self.assertEqual(
           nested_simplify(__snake_case       ,   decimals=6	)       ,   [
               [
                   {
                       '''score''': 2.2E-05,
                       '''token''': 35_676,
                       '''token_str''': ''' Maul''',
                       '''sequence''': '''<s>My name is Maul<mask></s>''',
                   },
                   {'''score''': 2.2E-05, '''token''': 16_416, '''token_str''': '''ELS''', '''sequence''': '''<s>My name isELS<mask></s>'''},
               ],
               [
                   {
                       '''score''': 2.2E-05,
                       '''token''': 35_676,
                       '''token_str''': ''' Maul''',
                       '''sequence''': '''<s>My name is<mask> Maul</s>''',
                   },
                   {'''score''': 2.2E-05, '''token''': 16_416, '''token_str''': '''ELS''', '''sequence''': '''<s>My name is<mask>ELS</s>'''},
               ],
           ]       ,   )





    @require_torch_gpu
    def 					_lowerCamelCase (	self				:   List[Any]	):





       '''simple docstring'''
       UpperCAmelCase_							:      List[Any]						=   pipeline('''fill-mask'''       ,   model='''hf-internal-testing/tiny-random-distilbert'''       ,   device=0       ,   framework='''pt'''	)

       # convert model to fp16
       pipe.model.half()

       UpperCAmelCase_							:      Optional[int]						=   pipe('''Paris is the [MASK] of France.'''	)
       # We actually don't care about the result, we just want to make sure
       # it works, meaning the float16 tensor got casted back to float32
       # for postprocessing.
       self.assertIsInstance(__snake_case       ,   __snake_case	)





    @slow
    @require_torch
    def 					_lowerCamelCase (	self				:   int	):





       '''simple docstring'''
       UpperCAmelCase_							:      Optional[int]						=   pipeline(task='''fill-mask'''       ,   model='''distilroberta-base'''       ,   top_k=2       ,   framework='''pt'''	)
       self.run_large_test(__snake_case	)





    @slow
    @require_tf
    def 					_lowerCamelCase (	self				:   str	):





       '''simple docstring'''
       UpperCAmelCase_							:      Union[str, Any]						=   pipeline(task='''fill-mask'''       ,   model='''distilroberta-base'''       ,   top_k=2       ,   framework='''tf'''	)
       self.run_large_test(__snake_case	)





    def 					_lowerCamelCase (	self				:   Optional[int]       ,   __snake_case				:   Any	):





       '''simple docstring'''
       UpperCAmelCase_							:      List[str]						=   unmasker('''My name is <mask>'''	)
       self.assertEqual(
           nested_simplify(__snake_case	)       ,   [
               {'''sequence''': '''My name is John''', '''score''': 0.008, '''token''': 610, '''token_str''': ''' John'''},
               {'''sequence''': '''My name is Chris''', '''score''': 0.007, '''token''': 1_573, '''token_str''': ''' Chris'''},
           ]       ,   )
       UpperCAmelCase_							:      Optional[Any]						=   unmasker('''The largest city in France is <mask>'''	)
       self.assertEqual(
           nested_simplify(__snake_case	)       ,   [
               {
                   '''sequence''': '''The largest city in France is Paris''',
                   '''score''': 0.251,
                   '''token''': 2_201,
                   '''token_str''': ''' Paris''',
               },
               {
                   '''sequence''': '''The largest city in France is Lyon''',
                   '''score''': 0.214,
                   '''token''': 12_790,
                   '''token_str''': ''' Lyon''',
               },
           ]       ,   )

       UpperCAmelCase_							:      List[str]						=   unmasker('''My name is <mask>'''       ,   targets=[''' Patrick''', ''' Clara''', ''' Teven''']       ,   top_k=3	)
       self.assertEqual(
           nested_simplify(__snake_case	)       ,   [
               {'''sequence''': '''My name is Patrick''', '''score''': 0.005, '''token''': 3_499, '''token_str''': ''' Patrick'''},
               {'''sequence''': '''My name is Clara''', '''score''': 0.000, '''token''': 13_606, '''token_str''': ''' Clara'''},
               {'''sequence''': '''My name is Te''', '''score''': 0.000, '''token''': 2_941, '''token_str''': ''' Te'''},
           ]       ,   )





    @require_torch
    def 					_lowerCamelCase (	self				:   List[Any]	):





       '''simple docstring'''
       UpperCAmelCase_							:      Tuple						=   pipeline(task='''fill-mask'''       ,   model='''sshleifer/tiny-distilroberta-base'''       ,   framework='''pt'''	)
       UpperCAmelCase_							:      Union[str, Any]						=   None
       UpperCAmelCase_							:      int						=   None
       self.run_pipeline_test(__snake_case       ,   []	)





    @require_tf
    def 					_lowerCamelCase (	self				:   Tuple	):





       '''simple docstring'''
       UpperCAmelCase_							:      List[str]						=   pipeline(task='''fill-mask'''       ,   model='''sshleifer/tiny-distilroberta-base'''       ,   framework='''tf'''	)
       UpperCAmelCase_							:      Any						=   None
       UpperCAmelCase_							:      int						=   None
       self.run_pipeline_test(__snake_case       ,   []	)





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





       '''simple docstring'''
       if tokenizer is None or tokenizer.mask_token_id is None:
          self.skipTest('''The provided tokenizer has no mask token, (probably reformer or wav2vec2)'''	)

       UpperCAmelCase_							:      Optional[Any]						=   FillMaskPipeline(model=__snake_case       ,   tokenizer=__snake_case	)
       UpperCAmelCase_							:      Any						=   [
           f'''This is another {tokenizer.mask_token} test''',
       ]
       return fill_masker, examples





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





       '''simple docstring'''
       UpperCAmelCase_							:      List[str]						=   fill_masker.tokenizer
       UpperCAmelCase_							:      Union[str, Any]						=   fill_masker.model

       UpperCAmelCase_							:      Any						=   fill_masker(
           f'''This is a {tokenizer.mask_token}'''       ,   )
       self.assertEqual(
           __snake_case       ,   [
               {'''sequence''': ANY(__snake_case	), '''score''': ANY(__snake_case	), '''token''': ANY(__snake_case	), '''token_str''': ANY(__snake_case	)},
               {'''sequence''': ANY(__snake_case	), '''score''': ANY(__snake_case	), '''token''': ANY(__snake_case	), '''token_str''': ANY(__snake_case	)},
               {'''sequence''': ANY(__snake_case	), '''score''': ANY(__snake_case	), '''token''': ANY(__snake_case	), '''token_str''': ANY(__snake_case	)},
               {'''sequence''': ANY(__snake_case	), '''score''': ANY(__snake_case	), '''token''': ANY(__snake_case	), '''token_str''': ANY(__snake_case	)},
               {'''sequence''': ANY(__snake_case	), '''score''': ANY(__snake_case	), '''token''': ANY(__snake_case	), '''token_str''': ANY(__snake_case	)},
           ]       ,   )

       UpperCAmelCase_							:      Dict						=   fill_masker([f'''This is a {tokenizer.mask_token}''']	)
       self.assertEqual(
           __snake_case       ,   [
               {'''sequence''': ANY(__snake_case	), '''score''': ANY(__snake_case	), '''token''': ANY(__snake_case	), '''token_str''': ANY(__snake_case	)},
               {'''sequence''': ANY(__snake_case	), '''score''': ANY(__snake_case	), '''token''': ANY(__snake_case	), '''token_str''': ANY(__snake_case	)},
               {'''sequence''': ANY(__snake_case	), '''score''': ANY(__snake_case	), '''token''': ANY(__snake_case	), '''token_str''': ANY(__snake_case	)},
               {'''sequence''': ANY(__snake_case	), '''score''': ANY(__snake_case	), '''token''': ANY(__snake_case	), '''token_str''': ANY(__snake_case	)},
               {'''sequence''': ANY(__snake_case	), '''score''': ANY(__snake_case	), '''token''': ANY(__snake_case	), '''token_str''': ANY(__snake_case	)},
           ]       ,   )

       UpperCAmelCase_							:      Any						=   fill_masker([f'''This is a {tokenizer.mask_token}''', f'''Another {tokenizer.mask_token} great test.''']	)
       self.assertEqual(
           __snake_case       ,   [
               [
                   {'''sequence''': ANY(__snake_case	), '''score''': ANY(__snake_case	), '''token''': ANY(__snake_case	), '''token_str''': ANY(__snake_case	)},
                   {'''sequence''': ANY(__snake_case	), '''score''': ANY(__snake_case	), '''token''': ANY(__snake_case	), '''token_str''': ANY(__snake_case	)},
                   {'''sequence''': ANY(__snake_case	), '''score''': ANY(__snake_case	), '''token''': ANY(__snake_case	), '''token_str''': ANY(__snake_case	)},
                   {'''sequence''': ANY(__snake_case	), '''score''': ANY(__snake_case	), '''token''': ANY(__snake_case	), '''token_str''': ANY(__snake_case	)},
                   {'''sequence''': ANY(__snake_case	), '''score''': ANY(__snake_case	), '''token''': ANY(__snake_case	), '''token_str''': ANY(__snake_case	)},
               ],
               [
                   {'''sequence''': ANY(__snake_case	), '''score''': ANY(__snake_case	), '''token''': ANY(__snake_case	), '''token_str''': ANY(__snake_case	)},
                   {'''sequence''': ANY(__snake_case	), '''score''': ANY(__snake_case	), '''token''': ANY(__snake_case	), '''token_str''': ANY(__snake_case	)},
                   {'''sequence''': ANY(__snake_case	), '''score''': ANY(__snake_case	), '''token''': ANY(__snake_case	), '''token_str''': ANY(__snake_case	)},
                   {'''sequence''': ANY(__snake_case	), '''score''': ANY(__snake_case	), '''token''': ANY(__snake_case	), '''token_str''': ANY(__snake_case	)},
                   {'''sequence''': ANY(__snake_case	), '''score''': ANY(__snake_case	), '''token''': ANY(__snake_case	), '''token_str''': ANY(__snake_case	)},
               ],
           ]       ,   )

       with self.assertRaises(__snake_case	):
          fill_masker([None]	)
       # No mask_token is not supported
       with self.assertRaises(__snake_case	):
          fill_masker('''This is'''	)

       self.run_test_top_k(__snake_case       ,   __snake_case	)
       self.run_test_targets(__snake_case       ,   __snake_case	)
       self.run_test_top_k_targets(__snake_case       ,   __snake_case	)
       self.fill_mask_with_duplicate_targets_and_top_k(__snake_case       ,   __snake_case	)
       self.fill_mask_with_multiple_masks(__snake_case       ,   __snake_case	)





    def 					_lowerCamelCase (	self				:   Optional[Any]       ,   __snake_case				:   int       ,   __snake_case				:   Any	):





       '''simple docstring'''
       UpperCAmelCase_							:      Dict						=   tokenizer.get_vocab()
       UpperCAmelCase_							:      Dict						=   sorted(vocab.keys()	)[:2]
       # Pipeline argument
       UpperCAmelCase_							:      Optional[int]						=   FillMaskPipeline(model=__snake_case       ,   tokenizer=__snake_case       ,   targets=__snake_case	)
       UpperCAmelCase_							:      str						=   fill_masker(f'''This is a {tokenizer.mask_token}'''	)
       self.assertEqual(
           __snake_case       ,   [
               {'''sequence''': ANY(__snake_case	), '''score''': ANY(__snake_case	), '''token''': ANY(__snake_case	), '''token_str''': ANY(__snake_case	)},
               {'''sequence''': ANY(__snake_case	), '''score''': ANY(__snake_case	), '''token''': ANY(__snake_case	), '''token_str''': ANY(__snake_case	)},
           ]       ,   )
       UpperCAmelCase_							:      List[Any]						=   {vocab[el] for el in targets}
       self.assertEqual({el['''token'''] for el in outputs}       ,   __snake_case	)
       UpperCAmelCase_							:      Tuple						=   [tokenizer.decode([x]	) for x in target_ids]
       self.assertEqual({el['''token_str'''] for el in outputs}       ,   set(__snake_case	)	)

       # Call argument
       UpperCAmelCase_							:      str						=   FillMaskPipeline(model=__snake_case       ,   tokenizer=__snake_case	)
       UpperCAmelCase_							:      str						=   fill_masker(f'''This is a {tokenizer.mask_token}'''       ,   targets=__snake_case	)
       self.assertEqual(
           __snake_case       ,   [
               {'''sequence''': ANY(__snake_case	), '''score''': ANY(__snake_case	), '''token''': ANY(__snake_case	), '''token_str''': ANY(__snake_case	)},
               {'''sequence''': ANY(__snake_case	), '''score''': ANY(__snake_case	), '''token''': ANY(__snake_case	), '''token_str''': ANY(__snake_case	)},
           ]       ,   )
       UpperCAmelCase_							:      List[str]						=   {vocab[el] for el in targets}
       self.assertEqual({el['''token'''] for el in outputs}       ,   __snake_case	)
       UpperCAmelCase_							:      int						=   [tokenizer.decode([x]	) for x in target_ids]
       self.assertEqual({el['''token_str'''] for el in outputs}       ,   set(__snake_case	)	)

       # Score equivalence
       UpperCAmelCase_							:      Union[str, Any]						=   fill_masker(f'''This is a {tokenizer.mask_token}'''       ,   targets=__snake_case	)
       UpperCAmelCase_							:      str						=   [top_mask['''token_str'''] for top_mask in outputs]
       UpperCAmelCase_							:      Tuple						=   [top_mask['''score'''] for top_mask in outputs]

       # For some BPE tokenizers, `</w>` is removed during decoding, so `token_str` won't be the same as in `targets`.
       if set(__snake_case	) == set(__snake_case	):
          UpperCAmelCase_							:      List[Any]						=   fill_masker(f'''This is a {tokenizer.mask_token}'''       ,   targets=__snake_case	)
          UpperCAmelCase_							:      Optional[Any]						=   [top_mask['''score'''] for top_mask in unmasked_targets]
          self.assertEqual(nested_simplify(__snake_case	)       ,   nested_simplify(__snake_case	)	)

       # Raises with invalid
       with self.assertRaises(__snake_case	):
          UpperCAmelCase_							:      Dict						=   fill_masker(f'''This is a {tokenizer.mask_token}'''       ,   targets=[]	)
       # For some tokenizers, `""` is actually in the vocabulary and the expected error won't raised
       if "" not in tokenizer.get_vocab():
          with self.assertRaises(__snake_case	):
             UpperCAmelCase_							:      Tuple						=   fill_masker(f'''This is a {tokenizer.mask_token}'''       ,   targets=['''''']	)
          with self.assertRaises(__snake_case	):
             UpperCAmelCase_							:      List[Any]						=   fill_masker(f'''This is a {tokenizer.mask_token}'''       ,   targets=''''''	)





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





       '''simple docstring'''
       UpperCAmelCase_							:      Optional[Any]						=   FillMaskPipeline(model=__snake_case       ,   tokenizer=__snake_case       ,   top_k=2	)
       UpperCAmelCase_							:      Tuple						=   fill_masker(f'''This is a {tokenizer.mask_token}'''	)
       self.assertEqual(
           __snake_case       ,   [
               {'''sequence''': ANY(__snake_case	), '''score''': ANY(__snake_case	), '''token''': ANY(__snake_case	), '''token_str''': ANY(__snake_case	)},
               {'''sequence''': ANY(__snake_case	), '''score''': ANY(__snake_case	), '''token''': ANY(__snake_case	), '''token_str''': ANY(__snake_case	)},
           ]       ,   )

       UpperCAmelCase_							:      Union[str, Any]						=   FillMaskPipeline(model=__snake_case       ,   tokenizer=__snake_case	)
       UpperCAmelCase_							:      Union[str, Any]						=   fill_masker(f'''This is a {tokenizer.mask_token}'''       ,   top_k=2	)
       self.assertEqual(
           __snake_case       ,   [
               {'''sequence''': ANY(__snake_case	), '''score''': ANY(__snake_case	), '''token''': ANY(__snake_case	), '''token_str''': ANY(__snake_case	)},
               {'''sequence''': ANY(__snake_case	), '''score''': ANY(__snake_case	), '''token''': ANY(__snake_case	), '''token_str''': ANY(__snake_case	)},
           ]       ,   )
       self.assertEqual(nested_simplify(__snake_case	)       ,   nested_simplify(__snake_case	)	)





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





       '''simple docstring'''
       UpperCAmelCase_							:      Dict						=   tokenizer.get_vocab()
       UpperCAmelCase_							:      Tuple						=   FillMaskPipeline(model=__snake_case       ,   tokenizer=__snake_case	)

       # top_k=2, ntargets=3
       UpperCAmelCase_							:      int						=   sorted(vocab.keys()	)[:3]
       UpperCAmelCase_							:      int						=   fill_masker(f'''This is a {tokenizer.mask_token}'''       ,   top_k=2       ,   targets=__snake_case	)

       # If we use the most probably targets, and filter differently, we should still
       # have the same results
       UpperCAmelCase_							:      Optional[int]						=   [el['''token_str'''] for el in sorted(__snake_case       ,   key=lambda __snake_case	: x["score"]       ,   reverse=__snake_case	)]
       # For some BPE tokenizers, `</w>` is removed during decoding, so `token_str` won't be the same as in `targets`.
       if set(__snake_case	).issubset(__snake_case	):
          UpperCAmelCase_							:      Dict						=   fill_masker(f'''This is a {tokenizer.mask_token}'''       ,   top_k=3       ,   targets=__snake_case	)
          # They should yield exactly the same result
          self.assertEqual(nested_simplify(__snake_case	)       ,   nested_simplify(__snake_case	)	)





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





       '''simple docstring'''
       UpperCAmelCase_							:      Dict						=   FillMaskPipeline(model=__snake_case       ,   tokenizer=__snake_case	)
       UpperCAmelCase_							:      Dict						=   tokenizer.get_vocab()
       # String duplicates + id duplicates
       UpperCAmelCase_							:      Optional[int]						=   sorted(vocab.keys()	)[:3]
       UpperCAmelCase_							:      Optional[Any]						=   [targets[0], targets[1], targets[0], targets[2], targets[1]]
       UpperCAmelCase_							:      str						=   fill_masker(f'''My name is {tokenizer.mask_token}'''       ,   targets=__snake_case       ,   top_k=10	)

       # The target list contains duplicates, so we can't output more
       # than them
       self.assertEqual(len(__snake_case	)       ,   3	)





    def 					_lowerCamelCase (	self				:   Any       ,   __snake_case				:   Dict       ,   __snake_case				:   Dict	):





       '''simple docstring'''
       UpperCAmelCase_							:      str						=   FillMaskPipeline(model=__snake_case       ,   tokenizer=__snake_case	)

       UpperCAmelCase_							:      str						=   fill_masker(
           f'''This is a {tokenizer.mask_token} {tokenizer.mask_token} {tokenizer.mask_token}'''       ,   top_k=2	)
       self.assertEqual(
           __snake_case       ,   [
               [
                   {'''sequence''': ANY(__snake_case	), '''score''': ANY(__snake_case	), '''token''': ANY(__snake_case	), '''token_str''': ANY(__snake_case	)},
                   {'''sequence''': ANY(__snake_case	), '''score''': ANY(__snake_case	), '''token''': ANY(__snake_case	), '''token_str''': ANY(__snake_case	)},
               ],
               [
                   {'''sequence''': ANY(__snake_case	), '''score''': ANY(__snake_case	), '''token''': ANY(__snake_case	), '''token_str''': ANY(__snake_case	)},
                   {'''sequence''': ANY(__snake_case	), '''score''': ANY(__snake_case	), '''token''': ANY(__snake_case	), '''token_str''': ANY(__snake_case	)},
               ],
               [
                   {'''sequence''': ANY(__snake_case	), '''score''': ANY(__snake_case	), '''token''': ANY(__snake_case	), '''token_str''': ANY(__snake_case	)},
                   {'''sequence''': ANY(__snake_case	), '''score''': ANY(__snake_case	), '''token''': ANY(__snake_case	), '''token_str''': ANY(__snake_case	)},
               ],
           ]       ,   )



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)}')