

'''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 						lowerCAmelCase__   (      unittest.TestCase					):



 """simple docstring"""



 lowerCAmelCase__  					=      MODEL_FOR_MASKED_LM_MAPPING
 lowerCAmelCase__  					=      TF_MODEL_FOR_MASKED_LM_MAPPING
 def       UpperCAmelCase__		(		self					:       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       UpperCAmelCase__		(		self					:       List[Any]			)  -> str:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE     =      pipeline(task="""fill-mask"""					,							model="""sshleifer/tiny-distilroberta-base"""					,							top_k=2					,							framework="""tf"""			)
      __SCREAMING_SNAKE_CASE     =      unmasker("""My name is <mask>"""			)
      self.assertEqual(
          nested_simplify(__SCREAMING_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"""},
          ]					,							)

      __SCREAMING_SNAKE_CASE     =      unmasker("""The largest city in France is <mask>"""			)
      self.assertEqual(
          nested_simplify(__SCREAMING_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""",
              },
          ]					,							)

      __SCREAMING_SNAKE_CASE     =      unmasker("""My name is <mask>"""					,							targets=[""" Patrick""", """ Clara""", """ Teven"""]					,							top_k=3			)
      self.assertEqual(
          nested_simplify(__SCREAMING_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       UpperCAmelCase__		(		self					:       List[Any]			)  -> Any:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE     =      pipeline(task="""fill-mask"""					,							model="""sshleifer/tiny-distilroberta-base"""					,							top_k=2					,							framework="""pt"""			)

      __SCREAMING_SNAKE_CASE     =      unmasker("""My name is <mask>"""			)
      self.assertEqual(
          nested_simplify(__SCREAMING_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"""},
          ]					,							)

      __SCREAMING_SNAKE_CASE     =      unmasker("""The largest city in France is <mask>"""			)
      self.assertEqual(
          nested_simplify(__SCREAMING_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"""},
          ]					,							)

      __SCREAMING_SNAKE_CASE     =      unmasker("""My name is <mask>"""					,							targets=[""" Patrick""", """ Clara""", """ Teven"""]					,							top_k=3			)
      self.assertEqual(
          nested_simplify(__SCREAMING_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"""},
          ]					,							)

      __SCREAMING_SNAKE_CASE     =      unmasker("""My name is <mask> <mask>"""					,							top_k=2			)

      self.assertEqual(
          nested_simplify(__SCREAMING_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       UpperCAmelCase__		(		self					:       int			)  -> int:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE     =      pipeline("""fill-mask"""					,							model="""hf-internal-testing/tiny-random-distilbert"""					,							device=0					,							framework="""pt"""			)

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

      __SCREAMING_SNAKE_CASE     =      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(__SCREAMING_SNAKE_CASE					,							__SCREAMING_SNAKE_CASE			)
 @slow
 @require_torch
 def       UpperCAmelCase__		(		self					:       Union[str, Any]			)  -> Dict:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE     =      pipeline(task="""fill-mask"""					,							model="""distilroberta-base"""					,							top_k=2					,							framework="""pt"""			)
      self.run_large_test(__SCREAMING_SNAKE_CASE			)
 @slow
 @require_tf
 def       UpperCAmelCase__		(		self					:       Tuple			)  -> Optional[int]:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE     =      pipeline(task="""fill-mask"""					,							model="""distilroberta-base"""					,							top_k=2					,							framework="""tf"""			)
      self.run_large_test(__SCREAMING_SNAKE_CASE			)
 def       UpperCAmelCase__		(		self					:       Any					,							__SCREAMING_SNAKE_CASE					:       List[Any]			)  -> Union[str, Any]:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE     =      unmasker("""My name is <mask>"""			)
      self.assertEqual(
          nested_simplify(__SCREAMING_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"""},
          ]					,							)
      __SCREAMING_SNAKE_CASE     =      unmasker("""The largest city in France is <mask>"""			)
      self.assertEqual(
          nested_simplify(__SCREAMING_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""",
              },
          ]					,							)

      __SCREAMING_SNAKE_CASE     =      unmasker("""My name is <mask>"""					,							targets=[""" Patrick""", """ Clara""", """ Teven"""]					,							top_k=3			)
      self.assertEqual(
          nested_simplify(__SCREAMING_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       UpperCAmelCase__		(		self					:       int			)  -> Tuple:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE     =      pipeline(task="""fill-mask"""					,							model="""sshleifer/tiny-distilroberta-base"""					,							framework="""pt"""			)
      __SCREAMING_SNAKE_CASE     =      None
      __SCREAMING_SNAKE_CASE     =      None
      self.run_pipeline_test(__SCREAMING_SNAKE_CASE					,							[]			)
 @require_tf
 def       UpperCAmelCase__		(		self					:       Union[str, Any]			)  -> Union[str, Any]:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE     =      pipeline(task="""fill-mask"""					,							model="""sshleifer/tiny-distilroberta-base"""					,							framework="""tf"""			)
      __SCREAMING_SNAKE_CASE     =      None
      __SCREAMING_SNAKE_CASE     =      None
      self.run_pipeline_test(__SCREAMING_SNAKE_CASE					,							[]			)
 def       UpperCAmelCase__		(		self					:       int					,							__SCREAMING_SNAKE_CASE					:       List[str]					,							__SCREAMING_SNAKE_CASE					:       Dict					,							__SCREAMING_SNAKE_CASE					:       List[Any]			)  -> Tuple:


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

      __SCREAMING_SNAKE_CASE     =      FillMaskPipeline(model=__SCREAMING_SNAKE_CASE					,							tokenizer=__SCREAMING_SNAKE_CASE			)
      __SCREAMING_SNAKE_CASE     =      [
          f'This is another {tokenizer.mask_token} test',
      ]
      return fill_masker, examples
 def       UpperCAmelCase__		(		self					:       Optional[Any]					,							__SCREAMING_SNAKE_CASE					:       int					,							__SCREAMING_SNAKE_CASE					:       Optional[int]			)  -> Any:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE     =      fill_masker.tokenizer
      __SCREAMING_SNAKE_CASE     =      fill_masker.model

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

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

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

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

      self.run_test_top_k(__SCREAMING_SNAKE_CASE					,							__SCREAMING_SNAKE_CASE			)
      self.run_test_targets(__SCREAMING_SNAKE_CASE					,							__SCREAMING_SNAKE_CASE			)
      self.run_test_top_k_targets(__SCREAMING_SNAKE_CASE					,							__SCREAMING_SNAKE_CASE			)
      self.fill_mask_with_duplicate_targets_and_top_k(__SCREAMING_SNAKE_CASE					,							__SCREAMING_SNAKE_CASE			)
      self.fill_mask_with_multiple_masks(__SCREAMING_SNAKE_CASE					,							__SCREAMING_SNAKE_CASE			)
 def       UpperCAmelCase__		(		self					:       int					,							__SCREAMING_SNAKE_CASE					:       List[Any]					,							__SCREAMING_SNAKE_CASE					:       Optional[Any]			)  -> Optional[int]:


      """simple docstring"""




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

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

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

      # Raises with invalid
      with self.assertRaises(__SCREAMING_SNAKE_CASE			):
           __SCREAMING_SNAKE_CASE     =      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(__SCREAMING_SNAKE_CASE			):
                __SCREAMING_SNAKE_CASE     =      fill_masker(f'This is a {tokenizer.mask_token}'					,							targets=[""""""]			)
           with self.assertRaises(__SCREAMING_SNAKE_CASE			):
                __SCREAMING_SNAKE_CASE     =      fill_masker(f'This is a {tokenizer.mask_token}'					,							targets=""""""			)
 def       UpperCAmelCase__		(		self					:       List[str]					,							__SCREAMING_SNAKE_CASE					:       List[str]					,							__SCREAMING_SNAKE_CASE					:       List[Any]			)  -> List[str]:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE     =      FillMaskPipeline(model=__SCREAMING_SNAKE_CASE					,							tokenizer=__SCREAMING_SNAKE_CASE					,							top_k=2			)
      __SCREAMING_SNAKE_CASE     =      fill_masker(f'This is a {tokenizer.mask_token}'			)
      self.assertEqual(
          __SCREAMING_SNAKE_CASE					,							[
              {"""sequence""": ANY(__SCREAMING_SNAKE_CASE			), """score""": ANY(__SCREAMING_SNAKE_CASE			), """token""": ANY(__SCREAMING_SNAKE_CASE			), """token_str""": ANY(__SCREAMING_SNAKE_CASE			)},
              {"""sequence""": ANY(__SCREAMING_SNAKE_CASE			), """score""": ANY(__SCREAMING_SNAKE_CASE			), """token""": ANY(__SCREAMING_SNAKE_CASE			), """token_str""": ANY(__SCREAMING_SNAKE_CASE			)},
          ]					,							)

      __SCREAMING_SNAKE_CASE     =      FillMaskPipeline(model=__SCREAMING_SNAKE_CASE					,							tokenizer=__SCREAMING_SNAKE_CASE			)
      __SCREAMING_SNAKE_CASE     =      fill_masker(f'This is a {tokenizer.mask_token}'					,							top_k=2			)
      self.assertEqual(
          __SCREAMING_SNAKE_CASE					,							[
              {"""sequence""": ANY(__SCREAMING_SNAKE_CASE			), """score""": ANY(__SCREAMING_SNAKE_CASE			), """token""": ANY(__SCREAMING_SNAKE_CASE			), """token_str""": ANY(__SCREAMING_SNAKE_CASE			)},
              {"""sequence""": ANY(__SCREAMING_SNAKE_CASE			), """score""": ANY(__SCREAMING_SNAKE_CASE			), """token""": ANY(__SCREAMING_SNAKE_CASE			), """token_str""": ANY(__SCREAMING_SNAKE_CASE			)},
          ]					,							)
      self.assertEqual(nested_simplify(__SCREAMING_SNAKE_CASE			)					,							nested_simplify(__SCREAMING_SNAKE_CASE			)			)
 def       UpperCAmelCase__		(		self					:       Any					,							__SCREAMING_SNAKE_CASE					:       Tuple					,							__SCREAMING_SNAKE_CASE					:       Any			)  -> Optional[Any]:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE     =      tokenizer.get_vocab()
      __SCREAMING_SNAKE_CASE     =      FillMaskPipeline(model=__SCREAMING_SNAKE_CASE					,							tokenizer=__SCREAMING_SNAKE_CASE			)

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

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


      """simple docstring"""




      __SCREAMING_SNAKE_CASE     =      FillMaskPipeline(model=__SCREAMING_SNAKE_CASE					,							tokenizer=__SCREAMING_SNAKE_CASE			)
      __SCREAMING_SNAKE_CASE     =      tokenizer.get_vocab()
      # String duplicates + id duplicates
      __SCREAMING_SNAKE_CASE     =      sorted(vocab.keys()			)[:3]
      __SCREAMING_SNAKE_CASE     =      [targets[0], targets[1], targets[0], targets[2], targets[1]]
      __SCREAMING_SNAKE_CASE     =      fill_masker(f'My name is {tokenizer.mask_token}'					,							targets=__SCREAMING_SNAKE_CASE					,							top_k=10			)

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


 def       UpperCAmelCase__		(		self					:       Optional[int]					,							__SCREAMING_SNAKE_CASE					:       str					,							__SCREAMING_SNAKE_CASE					:       Tuple			)  -> Any:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE     =      FillMaskPipeline(model=__SCREAMING_SNAKE_CASE					,							tokenizer=__SCREAMING_SNAKE_CASE			)

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









'''simple docstring'''



# Copyright 2021 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import argparse

from ...utils.dataclasses import (
    ComputeEnvironment,
    DistributedType,
    DynamoBackend,
    PrecisionType,
    SageMakerDistributedType,
)
from ..menu import BulletMenu


UpperCAmelCase :       Any			   =     [
    'EAGER',
    'AOT_EAGER',
    'INDUCTOR',
    'NVFUSER',
    'AOT_NVFUSER',
    'AOT_CUDAGRAPHS',
    'OFI',
    'FX2TRT',
    'ONNXRT',
    'IPEX',
]







def    a__       (  a__      ,    a__=None      ,    a__=None      ,    a__=None						):




     """simple docstring"""


     __SCREAMING_SNAKE_CASE     =      True
     while ask_again:
          __SCREAMING_SNAKE_CASE     =      input(a__						)
          try:
               if default is not None and len(a__						) == 0:
                    return default
               return convert_value(a__						) if convert_value is not None else result
          except Exception:
               if error_message is not None:
                    print(a__						)







def    a__       (  a__      ,    a__=[]      ,    a__=None      ,    a__=0						):




     """simple docstring"""


     __SCREAMING_SNAKE_CASE     =      BulletMenu(a__      ,    a__						)
     __SCREAMING_SNAKE_CASE     =      menu.run(default_choice=a__						)
     return convert_value(a__						) if convert_value is not None else result







def    a__       (  a__						):




     """simple docstring"""


     __SCREAMING_SNAKE_CASE     =      int(a__						)
     return ComputeEnvironment(["""LOCAL_MACHINE""", """AMAZON_SAGEMAKER"""][value]						)







def    a__       (  a__						):




     """simple docstring"""


     __SCREAMING_SNAKE_CASE     =      int(a__						)
     return DistributedType(["""NO""", """MULTI_CPU""", """MULTI_XPU""", """MULTI_GPU""", """MULTI_NPU""", """TPU"""][value]						)







def    a__       (  a__						):




     """simple docstring"""


     __SCREAMING_SNAKE_CASE     =      int(a__						)
     return DynamoBackend(DYNAMO_BACKENDS[value]						).value







def    a__       (  a__						):




     """simple docstring"""


     __SCREAMING_SNAKE_CASE     =      int(a__						)
     return PrecisionType(["""no""", """fp16""", """bf16""", """fp8"""][value]						)







def    a__       (  a__						):




     """simple docstring"""


     __SCREAMING_SNAKE_CASE     =      int(a__						)
     return SageMakerDistributedType(["""NO""", """DATA_PARALLEL""", """MODEL_PARALLEL"""][value]						)







def    a__       (  a__						):




     """simple docstring"""


     return {"yes": True, "no": False}[value.lower()]







class 						lowerCAmelCase__   (      argparse.RawDescriptionHelpFormatter					):



 """simple docstring"""



 def       UpperCAmelCase__		(		self					:       str					,							__SCREAMING_SNAKE_CASE					:       Optional[Any]					,							__SCREAMING_SNAKE_CASE					:       Dict					,							__SCREAMING_SNAKE_CASE					:       Optional[int]					,							__SCREAMING_SNAKE_CASE					:       List[Any]			)  -> Dict:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE     =      super()._format_usage(__SCREAMING_SNAKE_CASE					,							__SCREAMING_SNAKE_CASE					,							__SCREAMING_SNAKE_CASE					,							__SCREAMING_SNAKE_CASE			)
      __SCREAMING_SNAKE_CASE     =      usage.replace("""<command> [<args>] """					,							""""""			)
      return usage






