






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

     '''simple docstring'''






     snake_case__					=					MODEL_FOR_MASKED_LM_MAPPING
     snake_case__					=					TF_MODEL_FOR_MASKED_LM_MAPPING







     def   _SCREAMING_SNAKE_CASE     ( self      :    Dict ):






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






           """simple docstring"""




           UpperCamelCase					       =  pipeline(task='fill-mask'   ,						model='sshleifer/tiny-distilroberta-base'   ,						top_k=2   ,						framework='tf' )
           UpperCamelCase					       =  unmasker('My name is <mask>' )
           self.assertEqual(
               nested_simplify(_SCREAMING_SNAKE_CASE   ,						decimals=6 )   ,						[
                   {'sequence': 'My name is grouped', 'score': 2.1E-0_5, 'token': 3_8015, 'token_str': ' grouped'},
                   {'sequence': 'My name is accuser', 'score': 2.1E-0_5, 'token': 2_5506, 'token_str': ' accuser'},
               ]   ,						)

           UpperCamelCase					       =  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-0_5,
                       'token': 3_8015,
                       'token_str': ' grouped',
                   },
                   {
                       'sequence': 'The largest city in France is accuser',
                       'score': 2.1E-0_5,
                       'token': 2_5506,
                       'token_str': ' accuser',
                   },
               ]   ,						)

           UpperCamelCase					       =  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-0_5, 'token': 1_3606, 'token_str': ' Clara'},
                   {'sequence': 'My name is Patrick', 'score': 2E-0_5, 'token': 3499, 'token_str': ' Patrick'},
                   {'sequence': 'My name is Te', 'score': 1.9E-0_5, 'token': 2941, 'token_str': ' Te'},
               ]   ,						)







     @require_torch
     def   _SCREAMING_SNAKE_CASE     ( self      :    Dict ):






           """simple docstring"""




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

           UpperCamelCase					       =  unmasker('My name is <mask>' )
           self.assertEqual(
               nested_simplify(_SCREAMING_SNAKE_CASE   ,						decimals=6 )   ,						[
                   {'sequence': 'My name is Maul', 'score': 2.2E-0_5, 'token': 3_5676, 'token_str': ' Maul'},
                   {'sequence': 'My name isELS', 'score': 2.2E-0_5, 'token': 1_6416, 'token_str': 'ELS'},
               ]   ,						)

           UpperCamelCase					       =  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-0_5,
                       'token': 3_5676,
                       'token_str': ' Maul',
                   },
                   {'sequence': 'The largest city in France isELS', 'score': 2.2E-0_5, 'token': 1_6416, 'token_str': 'ELS'},
               ]   ,						)

           UpperCamelCase					       =  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-0_5, 'token': 3499, 'token_str': ' Patrick'},
                   {'sequence': 'My name is Te', 'score': 2E-0_5, 'token': 2941, 'token_str': ' Te'},
                   {'sequence': 'My name is Clara', 'score': 2E-0_5, 'token': 1_3606, 'token_str': ' Clara'},
               ]   ,						)

           UpperCamelCase					       =  unmasker('My name is <mask> <mask>'   ,						top_k=2 )

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







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






           """simple docstring"""




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

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

           UpperCamelCase					       =  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   _SCREAMING_SNAKE_CASE     ( self      :    Optional[int] ):






           """simple docstring"""




           UpperCamelCase					       =  pipeline(task='fill-mask'   ,						model='distilroberta-base'   ,						top_k=2   ,						framework='pt' )
           self.run_large_test(_SCREAMING_SNAKE_CASE )







     @slow
     @require_tf
     def   _SCREAMING_SNAKE_CASE     ( self      :    Union[str, Any] ):






           """simple docstring"""




           UpperCamelCase					       =  pipeline(task='fill-mask'   ,						model='distilroberta-base'   ,						top_k=2   ,						framework='tf' )
           self.run_large_test(_SCREAMING_SNAKE_CASE )







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






           """simple docstring"""




           UpperCamelCase					       =  unmasker('My name is <mask>' )
           self.assertEqual(
               nested_simplify(_SCREAMING_SNAKE_CASE )   ,						[
                   {'sequence': 'My name is John', 'score': 0.0_0_8, 'token': 610, 'token_str': ' John'},
                   {'sequence': 'My name is Chris', 'score': 0.0_0_7, 'token': 1573, 'token_str': ' Chris'},
               ]   ,						)
           UpperCamelCase					       =  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.2_5_1,
                       'token': 2201,
                       'token_str': ' Paris',
                   },
                   {
                       'sequence': 'The largest city in France is Lyon',
                       'score': 0.2_1_4,
                       'token': 1_2790,
                       'token_str': ' Lyon',
                   },
               ]   ,						)

           UpperCamelCase					       =  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.0_0_5, 'token': 3499, 'token_str': ' Patrick'},
                   {'sequence': 'My name is Clara', 'score': 0.0_0_0, 'token': 1_3606, 'token_str': ' Clara'},
                   {'sequence': 'My name is Te', 'score': 0.0_0_0, 'token': 2941, 'token_str': ' Te'},
               ]   ,						)







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






           """simple docstring"""




           UpperCamelCase					       =  pipeline(task='fill-mask'   ,						model='sshleifer/tiny-distilroberta-base'   ,						framework='pt' )
           UpperCamelCase					       =  None
           UpperCamelCase					       =  None
           self.run_pipeline_test(_SCREAMING_SNAKE_CASE   ,						[] )







     @require_tf
     def   _SCREAMING_SNAKE_CASE     ( self      :    List[str] ):






           """simple docstring"""




           UpperCamelCase					       =  pipeline(task='fill-mask'   ,						model='sshleifer/tiny-distilroberta-base'   ,						framework='tf' )
           UpperCamelCase					       =  None
           UpperCamelCase					       =  None
           self.run_pipeline_test(_SCREAMING_SNAKE_CASE   ,						[] )







     def   _SCREAMING_SNAKE_CASE     ( self      :    Dict   ,						_SCREAMING_SNAKE_CASE      :    Union[str, Any]   ,						_SCREAMING_SNAKE_CASE      :    str   ,						_SCREAMING_SNAKE_CASE      :    int ):






           """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					       =  FillMaskPipeline(model=_SCREAMING_SNAKE_CASE   ,						tokenizer=_SCREAMING_SNAKE_CASE )
           UpperCamelCase					       =  [
               f'This is another {tokenizer.mask_token} test',
           ]
           return fill_masker, examples







     def   _SCREAMING_SNAKE_CASE     ( self      :    Tuple   ,						_SCREAMING_SNAKE_CASE      :    List[Any]   ,						_SCREAMING_SNAKE_CASE      :    Dict ):






           """simple docstring"""




           UpperCamelCase					       =  fill_masker.tokenizer
           UpperCamelCase					       =  fill_masker.model

           UpperCamelCase					       =  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 )},
               ]   ,						)

           UpperCamelCase					       =  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 )},
               ]   ,						)

           UpperCamelCase					       =  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   _SCREAMING_SNAKE_CASE     ( self      :    List[str]   ,						_SCREAMING_SNAKE_CASE      :    Dict   ,						_SCREAMING_SNAKE_CASE      :    Union[str, Any] ):






           """simple docstring"""




           UpperCamelCase					       =  tokenizer.get_vocab()
           UpperCamelCase					       =  sorted(vocab.keys() )[:2]
           # Pipeline argument
           UpperCamelCase					       =  FillMaskPipeline(model=_SCREAMING_SNAKE_CASE   ,						tokenizer=_SCREAMING_SNAKE_CASE   ,						targets=_SCREAMING_SNAKE_CASE )
           UpperCamelCase					       =  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 )},
               ]   ,						)
           UpperCamelCase					       =  {vocab[el] for el in targets}
           self.assertEqual({el['token'] for el in outputs}   ,						_SCREAMING_SNAKE_CASE )
           UpperCamelCase					       =  [tokenizer.decode([x] ) for x in target_ids]
           self.assertEqual({el['token_str'] for el in outputs}   ,						set(_SCREAMING_SNAKE_CASE ) )

           # Call argument
           UpperCamelCase					       =  FillMaskPipeline(model=_SCREAMING_SNAKE_CASE   ,						tokenizer=_SCREAMING_SNAKE_CASE )
           UpperCamelCase					       =  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 )},
               ]   ,						)
           UpperCamelCase					       =  {vocab[el] for el in targets}
           self.assertEqual({el['token'] for el in outputs}   ,						_SCREAMING_SNAKE_CASE )
           UpperCamelCase					       =  [tokenizer.decode([x] ) for x in target_ids]
           self.assertEqual({el['token_str'] for el in outputs}   ,						set(_SCREAMING_SNAKE_CASE ) )

           # Score equivalence
           UpperCamelCase					       =  fill_masker(f'This is a {tokenizer.mask_token}'   ,						targets=_SCREAMING_SNAKE_CASE )
           UpperCamelCase					       =  [top_mask['token_str'] for top_mask in outputs]
           UpperCamelCase					       =  [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 ):
                 UpperCamelCase					       =  fill_masker(f'This is a {tokenizer.mask_token}'   ,						targets=_SCREAMING_SNAKE_CASE )
                 UpperCamelCase					       =  [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 ):
                 UpperCamelCase					       =  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 ):
                       UpperCamelCase					       =  fill_masker(f'This is a {tokenizer.mask_token}'   ,						targets=[''] )
                 with self.assertRaises(_SCREAMING_SNAKE_CASE ):
                       UpperCamelCase					       =  fill_masker(f'This is a {tokenizer.mask_token}'   ,						targets='' )







     def   _SCREAMING_SNAKE_CASE     ( self      :    Any   ,						_SCREAMING_SNAKE_CASE      :    Optional[Any]   ,						_SCREAMING_SNAKE_CASE      :    List[str] ):






           """simple docstring"""




           UpperCamelCase					       =  FillMaskPipeline(model=_SCREAMING_SNAKE_CASE   ,						tokenizer=_SCREAMING_SNAKE_CASE   ,						top_k=2 )
           UpperCamelCase					       =  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 )},
               ]   ,						)

           UpperCamelCase					       =  FillMaskPipeline(model=_SCREAMING_SNAKE_CASE   ,						tokenizer=_SCREAMING_SNAKE_CASE )
           UpperCamelCase					       =  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   _SCREAMING_SNAKE_CASE     ( self      :    Tuple   ,						_SCREAMING_SNAKE_CASE      :    Union[str, Any]   ,						_SCREAMING_SNAKE_CASE      :    Any ):






           """simple docstring"""




           UpperCamelCase					       =  tokenizer.get_vocab()
           UpperCamelCase					       =  FillMaskPipeline(model=_SCREAMING_SNAKE_CASE   ,						tokenizer=_SCREAMING_SNAKE_CASE )

           # top_k=2, ntargets=3
           UpperCamelCase					       =  sorted(vocab.keys() )[:3]
           UpperCamelCase					       =  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
           UpperCamelCase					       =  [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 ):
                 UpperCamelCase					       =  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   _SCREAMING_SNAKE_CASE     ( self      :    Any   ,						_SCREAMING_SNAKE_CASE      :    str   ,						_SCREAMING_SNAKE_CASE      :    Dict ):






           """simple docstring"""




           UpperCamelCase					       =  FillMaskPipeline(model=_SCREAMING_SNAKE_CASE   ,						tokenizer=_SCREAMING_SNAKE_CASE )
           UpperCamelCase					       =  tokenizer.get_vocab()
           # String duplicates + id duplicates
           UpperCamelCase					       =  sorted(vocab.keys() )[:3]
           UpperCamelCase					       =  [targets[0], targets[1], targets[0], targets[2], targets[1]]
           UpperCamelCase					       =  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   _SCREAMING_SNAKE_CASE     ( self      :    int   ,						_SCREAMING_SNAKE_CASE      :    Optional[Any]   ,						_SCREAMING_SNAKE_CASE      :    Union[str, Any] ):






           """simple docstring"""




           UpperCamelCase					       =  FillMaskPipeline(model=_SCREAMING_SNAKE_CASE   ,						tokenizer=_SCREAMING_SNAKE_CASE )

           UpperCamelCase					       =  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 )},
                   ],
               ]   ,						)











from datetime import datetime as dt
import os

from github import Github


__magic_name__   :  Dict        =							[
    '''good first issue''',
    '''good second issue''',
    '''good difficult issue''',
    '''feature request''',
    '''new model''',
    '''wip''',
]
def 		lowercase__  (				) ->			Dict:
      """simple docstring"""

      UpperCamelCase					       =  Github(os.environ['GITHUB_TOKEN'])
      UpperCamelCase					       =  g.get_repo('huggingface/transformers')
      UpperCamelCase					       =  repo.get_issues(state='open')

      for issue in open_issues:
            UpperCamelCase					       =  sorted([comment for comment in issue.get_comments()]       ,							key=lambda _UpperCamelCase: i.created_at       ,							reverse=_UpperCamelCase)
            UpperCamelCase					       =  comments[0] if len(_UpperCamelCase) > 0 else None
            if (
                last_comment is not None
                and last_comment.user.login == "github-actions[bot]"
                and (dt.utcnow() - issue.updated_at).days > 7
                and (dt.utcnow() - issue.created_at).days >= 30
                and not any(label.name.lower() in LABELS_TO_EXEMPT for label in issue.get_labels())
            ):
                  # print(f"Would close issue {issue.number} since it has been 7 days of inactivity since bot mention.")
                  issue.edit(state='closed')
            elif (
                (dt.utcnow() - issue.updated_at).days > 23
                and (dt.utcnow() - issue.created_at).days >= 30
                and not any(label.name.lower() in LABELS_TO_EXEMPT for label in issue.get_labels())
            ):
                  # print(f"Would add stale comment to {issue.number}")
                  issue.create_comment(
                      'This issue has been automatically marked as stale because it has not had '
                      'recent activity. If you think this still needs to be addressed '
                      'please comment on this thread.\n\nPlease note that issues that do not follow the '
                      '[contributing guidelines](https://github.com/huggingface/transformers/blob/main/CONTRIBUTING.md) '
                      'are likely to be ignored.')


if __name__ == "__main__":
       main()



