


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				):
 __lowercase			:							Union[str, Any]       					=			MODEL_FOR_MASKED_LM_MAPPING
 __lowercase			:							Union[str, Any]       					=			TF_MODEL_FOR_MASKED_LM_MAPPING
 def 		SCREAMING_SNAKE_CASE__       (       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 		SCREAMING_SNAKE_CASE__       (       self			) ->    Any:




        '''simple docstring'''
        lowercase__:       List[Any]        =       pipeline(task='fill-mask'    ,			model='sshleifer/tiny-distilroberta-base'    ,			top_k=2    ,			framework='tf'			)
        lowercase__:       Optional[Any]        =       unmasker('My name is <mask>'			)
        self.assertEqual(
            nested_simplify(lowerCAmelCase__    ,			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'},
            ]    ,			)

        lowercase__:       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': 38_015,
                    'token_str': ' grouped',
                },
                {
                    'sequence': 'The largest city in France is accuser',
                    'score': 2.1E-05,
                    'token': 25_506,
                    'token_str': ' accuser',
                },
            ]    ,			)

        lowercase__:       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': 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 		SCREAMING_SNAKE_CASE__       (       self			) ->    Tuple:




        '''simple docstring'''
        lowercase__:       Optional[int]        =       pipeline(task='fill-mask'    ,			model='sshleifer/tiny-distilroberta-base'    ,			top_k=2    ,			framework='pt'			)

        lowercase__:       Dict        =       unmasker('My name is <mask>'			)
        self.assertEqual(
            nested_simplify(lowerCAmelCase__    ,			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'},
            ]    ,			)

        lowercase__:       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': 35_676,
                    'token_str': ' Maul',
                },
                {'sequence': 'The largest city in France isELS', 'score': 2.2E-05, 'token': 16_416, 'token_str': 'ELS'},
            ]    ,			)

        lowercase__:       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_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'},
            ]    ,			)

        lowercase__:       Union[str, Any]        =       unmasker('My name is <mask> <mask>'    ,			top_k=2			)

        self.assertEqual(
            nested_simplify(lowerCAmelCase__    ,			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 		SCREAMING_SNAKE_CASE__       (       self			) ->    Optional[Any]:




        '''simple docstring'''
        lowercase__:       int        =       pipeline('fill-mask'    ,			model='hf-internal-testing/tiny-random-distilbert'    ,			device=0    ,			framework='pt'			)

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

        lowercase__:       List[str]        =       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			) ->    Optional[int]:




        '''simple docstring'''
        lowercase__:       int        =       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			) ->    Union[str, Any]:




        '''simple docstring'''
        lowercase__:       Tuple        =       pipeline(task='fill-mask'    ,			model='distilroberta-base'    ,			top_k=2    ,			framework='tf'			)
        self.run_large_test(lowerCAmelCase__			)
 def 		SCREAMING_SNAKE_CASE__       (       self    ,			lowerCAmelCase__			) ->    Tuple:




        '''simple docstring'''
        lowercase__:       List[Any]        =       unmasker('My name is <mask>'			)
        self.assertEqual(
            nested_simplify(lowerCAmelCase__			)    ,			[
                {'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': 1_573, 'token_str': ' Chris'},
            ]    ,			)
        lowercase__:       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_5_1,
                    'token': 2_201,
                    'token_str': ' Paris',
                },
                {
                    'sequence': 'The largest city in France is Lyon',
                    'score': 0.2_1_4,
                    'token': 12_790,
                    'token_str': ' Lyon',
                },
            ]    ,			)

        lowercase__:       List[Any]        =       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_0_5, 'token': 3_499, 'token_str': ' Patrick'},
                {'sequence': 'My name is Clara', 'score': 0.0_0_0, 'token': 13_606, 'token_str': ' Clara'},
                {'sequence': 'My name is Te', 'score': 0.0_0_0, 'token': 2_941, 'token_str': ' Te'},
            ]    ,			)
 @require_torch
 def 		SCREAMING_SNAKE_CASE__       (       self			) ->    Tuple:




        '''simple docstring'''
        lowercase__:       Union[str, Any]        =       pipeline(task='fill-mask'    ,			model='sshleifer/tiny-distilroberta-base'    ,			framework='pt'			)
        lowercase__:       str        =       None
        lowercase__:       Optional[int]        =       None
        self.run_pipeline_test(lowerCAmelCase__    ,			[]			)
 @require_tf
 def 		SCREAMING_SNAKE_CASE__       (       self			) ->    int:




        '''simple docstring'''
        lowercase__:       Dict        =       pipeline(task='fill-mask'    ,			model='sshleifer/tiny-distilroberta-base'    ,			framework='tf'			)
        lowercase__:       str        =       None
        lowercase__:       Optional[Any]        =       None
        self.run_pipeline_test(lowerCAmelCase__    ,			[]			)
 def 		SCREAMING_SNAKE_CASE__       (       self    ,			lowerCAmelCase__    ,			lowerCAmelCase__    ,			lowerCAmelCase__			) ->    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)'			)

        lowercase__:       Any        =       FillMaskPipeline(model=lowerCAmelCase__    ,			tokenizer=lowerCAmelCase__			)
        lowercase__:       str        =       [
            F'This is another {tokenizer.mask_token} test',
        ]
        return fill_masker, examples
 def 		SCREAMING_SNAKE_CASE__       (       self    ,			lowerCAmelCase__    ,			lowerCAmelCase__			) ->    Optional[Any]:




        '''simple docstring'''
        lowercase__:       str        =       fill_masker.tokenizer
        lowercase__:       List[Any]        =       fill_masker.model

        lowercase__:       Any        =       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__			)},
            ]    ,			)

        lowercase__:       Optional[Any]        =       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__			)},
            ]    ,			)

        lowercase__:       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    ,			lowerCAmelCase__    ,			lowerCAmelCase__			) ->    int:




        '''simple docstring'''
        lowercase__:       List[str]        =       tokenizer.get_vocab()
        lowercase__:       int        =       sorted(vocab.keys()			)[:2]
        # Pipeline argument
        lowercase__:       Optional[int]        =       FillMaskPipeline(model=lowerCAmelCase__    ,			tokenizer=lowerCAmelCase__    ,			targets=lowerCAmelCase__			)
        lowercase__:       Optional[Any]        =       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__			)},
            ]    ,			)
        lowercase__:       int        =       {vocab[el] for el in targets}
        self.assertEqual({el['token'] for el in outputs}    ,			lowerCAmelCase__			)
        lowercase__:       Tuple        =       [tokenizer.decode([x]			) for x in target_ids]
        self.assertEqual({el['token_str'] for el in outputs}    ,			set(lowerCAmelCase__			)			)

        # Call argument
        lowercase__:       Optional[Any]        =       FillMaskPipeline(model=lowerCAmelCase__    ,			tokenizer=lowerCAmelCase__			)
        lowercase__:       Any        =       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__			)},
            ]    ,			)
        lowercase__:       List[str]        =       {vocab[el] for el in targets}
        self.assertEqual({el['token'] for el in outputs}    ,			lowerCAmelCase__			)
        lowercase__:       str        =       [tokenizer.decode([x]			) for x in target_ids]
        self.assertEqual({el['token_str'] for el in outputs}    ,			set(lowerCAmelCase__			)			)

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

        # Raises with invalid
        with self.assertRaises(lowerCAmelCase__			):
               lowercase__:       Optional[int]        =       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__			):
                      lowercase__:       Optional[Any]        =       fill_masker(F'This is a {tokenizer.mask_token}'    ,			targets=['']			)
               with self.assertRaises(lowerCAmelCase__			):
                      lowercase__:       Optional[int]        =       fill_masker(F'This is a {tokenizer.mask_token}'    ,			targets=''			)
 def 		SCREAMING_SNAKE_CASE__       (       self    ,			lowerCAmelCase__    ,			lowerCAmelCase__			) ->    Any:




        '''simple docstring'''
        lowercase__:       Optional[Any]        =       FillMaskPipeline(model=lowerCAmelCase__    ,			tokenizer=lowerCAmelCase__    ,			top_k=2			)
        lowercase__:       List[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__			)},
            ]    ,			)

        lowercase__:       Optional[int]        =       FillMaskPipeline(model=lowerCAmelCase__    ,			tokenizer=lowerCAmelCase__			)
        lowercase__:       Dict        =       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    ,			lowerCAmelCase__    ,			lowerCAmelCase__			) ->    Union[str, Any]:




        '''simple docstring'''
        lowercase__:       List[str]        =       tokenizer.get_vocab()
        lowercase__:       int        =       FillMaskPipeline(model=lowerCAmelCase__    ,			tokenizer=lowerCAmelCase__			)

        # top_k=2, ntargets=3
        lowercase__:       List[Any]        =       sorted(vocab.keys()			)[:3]
        lowercase__:       Dict        =       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
        lowercase__:       int        =       [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__			):
               lowercase__:       int        =       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    ,			lowerCAmelCase__    ,			lowerCAmelCase__			) ->    int:




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

        # The target list contains duplicates, so we can't output more
        # than them
        self.assertEqual(len(lowerCAmelCase__			)    ,			3			)
 def 		SCREAMING_SNAKE_CASE__       (       self    ,			lowerCAmelCase__    ,			lowerCAmelCase__			) ->    Union[str, Any]:




        '''simple docstring'''
        lowercase__:       int        =       FillMaskPipeline(model=lowerCAmelCase__    ,			tokenizer=lowerCAmelCase__			)

        lowercase__:       List[str]        =       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__			)},
                ],
            ]    ,			)






from __future__ import annotations




def        snake_case_					(  snake_case      ,							snake_case					)  ->    list[int]:
       lowercase__:       Tuple        =       0
       lowercase__:       str        =       len(snake_case					) - 1

       while i < j:
              if nums[i] + nums[j] == target:
                     return [i, j]
              elif nums[i] + nums[j] < target:
                     lowercase__:       str        =       i + 1
              else:
                     lowercase__:       Dict        =       j - 1

       return []


if __name__ == "__main__":
 import doctest

 doctest.testmod()
 print(F'''{two_pointer([2, 7, 11, 15], 9) = }''')


