



"""simple docstring"""






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 	__snake_case	(     unittest.TestCase):
  snake_case__    :       int        =						MODEL_FOR_MASKED_LM_MAPPING
  snake_case__    :       Optional[int]        =						TF_MODEL_FOR_MASKED_LM_MAPPING




  def 						SCREAMING_SNAKE_CASE    (			self					:						Optional[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 						SCREAMING_SNAKE_CASE    (			self					:						Optional[int]		):






         """simple docstring"""






         _lowerCamelCase						:    List[str]         =			pipeline(task='''fill-mask'''						, model='''sshleifer/tiny-distilroberta-base'''						, top_k=2						, framework='''tf'''		)
         _lowerCamelCase						:    Union[str, Any]         =			unmasker('''My name is <mask>'''		)
         self.assertEqual(
             nested_simplify(__lowerCAmelCase						, decimals=6		)						, [
                 {'''sequence''': '''My name is grouped''', '''score''': 2.1E-05, '''token''': 3_8_0_1_5, '''token_str''': ''' grouped'''},
                 {'''sequence''': '''My name is accuser''', '''score''': 2.1E-05, '''token''': 2_5_5_0_6, '''token_str''': ''' accuser'''},
             ]						, )

         _lowerCamelCase						:    Any         =			unmasker('''The largest city in France is <mask>'''		)
         self.assertEqual(
             nested_simplify(__lowerCAmelCase						, decimals=6		)						, [
                 {
                     '''sequence''': '''The largest city in France is grouped''',
                     '''score''': 2.1E-05,
                     '''token''': 3_8_0_1_5,
                     '''token_str''': ''' grouped''',
                 },
                 {
                     '''sequence''': '''The largest city in France is accuser''',
                     '''score''': 2.1E-05,
                     '''token''': 2_5_5_0_6,
                     '''token_str''': ''' accuser''',
                 },
             ]						, )

         _lowerCamelCase						:    List[Any]         =			unmasker('''My name is <mask>'''						, targets=[''' Patrick''', ''' Clara''', ''' Teven''']						, top_k=3		)
         self.assertEqual(
             nested_simplify(__lowerCAmelCase						, decimals=6		)						, [
                 {'''sequence''': '''My name is Clara''', '''score''': 2E-05, '''token''': 1_3_6_0_6, '''token_str''': ''' Clara'''},
                 {'''sequence''': '''My name is Patrick''', '''score''': 2E-05, '''token''': 3_4_9_9, '''token_str''': ''' Patrick'''},
                 {'''sequence''': '''My name is Te''', '''score''': 1.9E-05, '''token''': 2_9_4_1, '''token_str''': ''' Te'''},
             ]						, )




  @require_torch
  def 						SCREAMING_SNAKE_CASE    (			self					:						List[str]		):






         """simple docstring"""






         _lowerCamelCase						:    int         =			pipeline(task='''fill-mask'''						, model='''sshleifer/tiny-distilroberta-base'''						, top_k=2						, framework='''pt'''		)

         _lowerCamelCase						:    Dict         =			unmasker('''My name is <mask>'''		)
         self.assertEqual(
             nested_simplify(__lowerCAmelCase						, decimals=6		)						, [
                 {'''sequence''': '''My name is Maul''', '''score''': 2.2E-05, '''token''': 3_5_6_7_6, '''token_str''': ''' Maul'''},
                 {'''sequence''': '''My name isELS''', '''score''': 2.2E-05, '''token''': 1_6_4_1_6, '''token_str''': '''ELS'''},
             ]						, )

         _lowerCamelCase						:    Optional[int]         =			unmasker('''The largest city in France is <mask>'''		)
         self.assertEqual(
             nested_simplify(__lowerCAmelCase						, decimals=6		)						, [
                 {
                     '''sequence''': '''The largest city in France is Maul''',
                     '''score''': 2.2E-05,
                     '''token''': 3_5_6_7_6,
                     '''token_str''': ''' Maul''',
                 },
                 {'''sequence''': '''The largest city in France isELS''', '''score''': 2.2E-05, '''token''': 1_6_4_1_6, '''token_str''': '''ELS'''},
             ]						, )

         _lowerCamelCase						:    str         =			unmasker('''My name is <mask>'''						, targets=[''' Patrick''', ''' Clara''', ''' Teven''']						, top_k=3		)
         self.assertEqual(
             nested_simplify(__lowerCAmelCase						, decimals=6		)						, [
                 {'''sequence''': '''My name is Patrick''', '''score''': 2.1E-05, '''token''': 3_4_9_9, '''token_str''': ''' Patrick'''},
                 {'''sequence''': '''My name is Te''', '''score''': 2E-05, '''token''': 2_9_4_1, '''token_str''': ''' Te'''},
                 {'''sequence''': '''My name is Clara''', '''score''': 2E-05, '''token''': 1_3_6_0_6, '''token_str''': ''' Clara'''},
             ]						, )

         _lowerCamelCase						:    Optional[int]         =			unmasker('''My name is <mask> <mask>'''						, top_k=2		)

         self.assertEqual(
             nested_simplify(__lowerCAmelCase						, decimals=6		)						, [
                 [
                     {
                         '''score''': 2.2E-05,
                         '''token''': 3_5_6_7_6,
                         '''token_str''': ''' Maul''',
                         '''sequence''': '''<s>My name is Maul<mask></s>''',
                     },
                     {'''score''': 2.2E-05, '''token''': 1_6_4_1_6, '''token_str''': '''ELS''', '''sequence''': '''<s>My name isELS<mask></s>'''},
                 ],
                 [
                     {
                         '''score''': 2.2E-05,
                         '''token''': 3_5_6_7_6,
                         '''token_str''': ''' Maul''',
                         '''sequence''': '''<s>My name is<mask> Maul</s>''',
                     },
                     {'''score''': 2.2E-05, '''token''': 1_6_4_1_6, '''token_str''': '''ELS''', '''sequence''': '''<s>My name is<mask>ELS</s>'''},
                 ],
             ]						, )




  @require_torch_gpu
  def 						SCREAMING_SNAKE_CASE    (			self					:						Union[str, Any]		):






         """simple docstring"""






         _lowerCamelCase						:    Any         =			pipeline('''fill-mask'''						, model='''hf-internal-testing/tiny-random-distilbert'''						, device=0						, framework='''pt'''		)

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

         _lowerCamelCase						:    Any         =			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(__lowerCAmelCase						, __lowerCAmelCase		)




  @slow
  @require_torch
  def 						SCREAMING_SNAKE_CASE    (			self					:						Union[str, Any]		):






         """simple docstring"""






         _lowerCamelCase						:    List[str]         =			pipeline(task='''fill-mask'''						, model='''distilroberta-base'''						, top_k=2						, framework='''pt'''		)
         self.run_large_test(__lowerCAmelCase		)




  @slow
  @require_tf
  def 						SCREAMING_SNAKE_CASE    (			self					:						List[Any]		):






         """simple docstring"""






         _lowerCamelCase						:    Dict         =			pipeline(task='''fill-mask'''						, model='''distilroberta-base'''						, top_k=2						, framework='''tf'''		)
         self.run_large_test(__lowerCAmelCase		)




  def 						SCREAMING_SNAKE_CASE    (			self					:						Union[str, Any]						, __lowerCAmelCase					:						List[Any]		):






         """simple docstring"""






         _lowerCamelCase						:    Any         =			unmasker('''My name is <mask>'''		)
         self.assertEqual(
             nested_simplify(__lowerCAmelCase		)						, [
                 {'''sequence''': '''My name is John''', '''score''': 0.0_08, '''token''': 6_1_0, '''token_str''': ''' John'''},
                 {'''sequence''': '''My name is Chris''', '''score''': 0.0_07, '''token''': 1_5_7_3, '''token_str''': ''' Chris'''},
             ]						, )
         _lowerCamelCase						:    List[str]         =			unmasker('''The largest city in France is <mask>'''		)
         self.assertEqual(
             nested_simplify(__lowerCAmelCase		)						, [
                 {
                     '''sequence''': '''The largest city in France is Paris''',
                     '''score''': 0.2_51,
                     '''token''': 2_2_0_1,
                     '''token_str''': ''' Paris''',
                 },
                 {
                     '''sequence''': '''The largest city in France is Lyon''',
                     '''score''': 0.2_14,
                     '''token''': 1_2_7_9_0,
                     '''token_str''': ''' Lyon''',
                 },
             ]						, )

         _lowerCamelCase						:    List[str]         =			unmasker('''My name is <mask>'''						, targets=[''' Patrick''', ''' Clara''', ''' Teven''']						, top_k=3		)
         self.assertEqual(
             nested_simplify(__lowerCAmelCase		)						, [
                 {'''sequence''': '''My name is Patrick''', '''score''': 0.0_05, '''token''': 3_4_9_9, '''token_str''': ''' Patrick'''},
                 {'''sequence''': '''My name is Clara''', '''score''': 0.0_00, '''token''': 1_3_6_0_6, '''token_str''': ''' Clara'''},
                 {'''sequence''': '''My name is Te''', '''score''': 0.0_00, '''token''': 2_9_4_1, '''token_str''': ''' Te'''},
             ]						, )




  @require_torch
  def 						SCREAMING_SNAKE_CASE    (			self					:						Optional[int]		):






         """simple docstring"""






         _lowerCamelCase						:    Dict         =			pipeline(task='''fill-mask'''						, model='''sshleifer/tiny-distilroberta-base'''						, framework='''pt'''		)
         _lowerCamelCase						:    Dict         =			None
         _lowerCamelCase						:    List[Any]         =			None
         self.run_pipeline_test(__lowerCAmelCase						, []		)




  @require_tf
  def 						SCREAMING_SNAKE_CASE    (			self					:						List[Any]		):






         """simple docstring"""






         _lowerCamelCase						:    int         =			pipeline(task='''fill-mask'''						, model='''sshleifer/tiny-distilroberta-base'''						, framework='''tf'''		)
         _lowerCamelCase						:    List[str]         =			None
         _lowerCamelCase						:    Tuple         =			None
         self.run_pipeline_test(__lowerCAmelCase						, []		)




  def 						SCREAMING_SNAKE_CASE    (			self					:						int						, __lowerCAmelCase					:						int						, __lowerCAmelCase					:						List[Any]						, __lowerCAmelCase					:						Any		):






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

         _lowerCamelCase						:    Union[str, Any]         =			FillMaskPipeline(model=__lowerCAmelCase						, tokenizer=__lowerCAmelCase		)
         _lowerCamelCase						:    List[Any]         =			[
             f'''This is another {tokenizer.mask_token} test''',
         ]
         return fill_masker, examples




  def 						SCREAMING_SNAKE_CASE    (			self					:						Optional[int]						, __lowerCAmelCase					:						Union[str, Any]						, __lowerCAmelCase					:						Union[str, Any]		):






         """simple docstring"""






         _lowerCamelCase						:    str         =			fill_masker.tokenizer
         _lowerCamelCase						:    Tuple         =			fill_masker.model

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

         _lowerCamelCase						:    Optional[int]         =			fill_masker([f'''This is a {tokenizer.mask_token}''']		)
         self.assertEqual(
             __lowerCAmelCase						, [
                 {'''sequence''': ANY(__lowerCAmelCase		), '''score''': ANY(__lowerCAmelCase		), '''token''': ANY(__lowerCAmelCase		), '''token_str''': ANY(__lowerCAmelCase		)},
                 {'''sequence''': ANY(__lowerCAmelCase		), '''score''': ANY(__lowerCAmelCase		), '''token''': ANY(__lowerCAmelCase		), '''token_str''': ANY(__lowerCAmelCase		)},
                 {'''sequence''': ANY(__lowerCAmelCase		), '''score''': ANY(__lowerCAmelCase		), '''token''': ANY(__lowerCAmelCase		), '''token_str''': ANY(__lowerCAmelCase		)},
                 {'''sequence''': ANY(__lowerCAmelCase		), '''score''': ANY(__lowerCAmelCase		), '''token''': ANY(__lowerCAmelCase		), '''token_str''': ANY(__lowerCAmelCase		)},
                 {'''sequence''': ANY(__lowerCAmelCase		), '''score''': ANY(__lowerCAmelCase		), '''token''': ANY(__lowerCAmelCase		), '''token_str''': ANY(__lowerCAmelCase		)},
             ]						, )

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

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

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




  def 						SCREAMING_SNAKE_CASE    (			self					:						str						, __lowerCAmelCase					:						List[str]						, __lowerCAmelCase					:						List[str]		):






         """simple docstring"""






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

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

         # Score equivalence
         _lowerCamelCase						:    str         =			fill_masker(f'''This is a {tokenizer.mask_token}'''						, targets=__lowerCAmelCase		)
         _lowerCamelCase						:    Dict         =			[top_mask['''token_str'''] for top_mask in outputs]
         _lowerCamelCase						:    Optional[Any]         =			[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(__lowerCAmelCase		) == set(__lowerCAmelCase		):
                _lowerCamelCase						:    int         =			fill_masker(f'''This is a {tokenizer.mask_token}'''						, targets=__lowerCAmelCase		)
                _lowerCamelCase						:    Union[str, Any]         =			[top_mask['''score'''] for top_mask in unmasked_targets]
                self.assertEqual(nested_simplify(__lowerCAmelCase		)						, nested_simplify(__lowerCAmelCase		)		)

         # Raises with invalid
         with self.assertRaises(__lowerCAmelCase		):
                _lowerCamelCase						:    Optional[Any]         =			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(__lowerCAmelCase		):
                       _lowerCamelCase						:    str         =			fill_masker(f'''This is a {tokenizer.mask_token}'''						, targets=['''''']		)
                with self.assertRaises(__lowerCAmelCase		):
                       _lowerCamelCase						:    Union[str, Any]         =			fill_masker(f'''This is a {tokenizer.mask_token}'''						, targets=''''''		)




  def 						SCREAMING_SNAKE_CASE    (			self					:						Union[str, Any]						, __lowerCAmelCase					:						Tuple						, __lowerCAmelCase					:						Any		):






         """simple docstring"""






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

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




  def 						SCREAMING_SNAKE_CASE    (			self					:						Any						, __lowerCAmelCase					:						List[str]						, __lowerCAmelCase					:						Optional[int]		):






         """simple docstring"""






         _lowerCamelCase						:    Tuple         =			tokenizer.get_vocab()
         _lowerCamelCase						:    Optional[int]         =			FillMaskPipeline(model=__lowerCAmelCase						, tokenizer=__lowerCAmelCase		)

         # top_k=2, ntargets=3
         _lowerCamelCase						:    List[Any]         =			sorted(vocab.keys()		)[:3]
         _lowerCamelCase						:    str         =			fill_masker(f'''This is a {tokenizer.mask_token}'''						, top_k=2						, targets=__lowerCAmelCase		)

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




  def 						SCREAMING_SNAKE_CASE    (			self					:						List[Any]						, __lowerCAmelCase					:						int						, __lowerCAmelCase					:						int		):






         """simple docstring"""






         _lowerCamelCase						:    Optional[int]         =			FillMaskPipeline(model=__lowerCAmelCase						, tokenizer=__lowerCAmelCase		)
         _lowerCamelCase						:    str         =			tokenizer.get_vocab()
         # String duplicates + id duplicates
         _lowerCamelCase						:    List[Any]         =			sorted(vocab.keys()		)[:3]
         _lowerCamelCase						:    Union[str, Any]         =			[targets[0], targets[1], targets[0], targets[2], targets[1]]
         _lowerCamelCase						:    Union[str, Any]         =			fill_masker(f'''My name is {tokenizer.mask_token}'''						, targets=__lowerCAmelCase						, top_k=1_0		)

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




  def 						SCREAMING_SNAKE_CASE    (			self					:						List[Any]						, __lowerCAmelCase					:						List[Any]						, __lowerCAmelCase					:						int		):






         """simple docstring"""






         _lowerCamelCase						:    Dict         =			FillMaskPipeline(model=__lowerCAmelCase						, tokenizer=__lowerCAmelCase		)

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







"""simple docstring"""






import argparse


lowerCAmelCase__      =    '''docs/source/_static/js/custom.js'''






def 	snake_case_  (				A_ :		List[str]						):


       '''simple docstring'''





       with open(A_,    encoding='''utf-8''',    newline='''\n'''						) as f:
              _lowerCamelCase						:    int         =			f.readlines()
       _lowerCamelCase						:    List[str]         =			0

       # First let's put the right version
       while not lines[index].startswith('''const stableVersion ='''						):
              index += 1
       _lowerCamelCase						:    List[Any]         =			F'''const stableVersion = "v{version}"\n'''

       # Then update the dictionary
       while not lines[index].startswith('''const versionMapping = {'''						):
              index += 1

       # We go until the end
       while not lines[index].startswith('''}'''						):
              index += 1
       # We add the new version at the end
       lines[index - 1] += F'''    "v{version}": "v{version}",\n'''

       with open(A_,    '''w''',    encoding='''utf-8''',    newline='''\n'''						) as f:
              f.writelines(A_						)


if __name__ == "__main__":
   lowerCAmelCase__      =    argparse.ArgumentParser()
   parser.add_argument('''--version''', help='''Release version.''')
   lowerCAmelCase__      =    parser.parse_args()
   update_custom_js(args.version)


