
"""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 ):
							UpperCAmelCase__      =   MODEL_FOR_MASKED_LM_MAPPING
							UpperCAmelCase__      =   TF_MODEL_FOR_MASKED_LM_MAPPING

							def _lowercase       (self     ):

									"""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 _lowercase       (self     ):

									"""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-0_5, '''token''': 3_80_15, '''token_str''': ''' grouped'''},
									        {'''sequence''': '''My name is accuser''', '''score''': 2.1e-0_5, '''token''': 2_55_06, '''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-0_5,
									            '''token''': 3_80_15,
									            '''token_str''': ''' grouped''',
									        },
									        {
									            '''sequence''': '''The largest city in France is accuser''',
									            '''score''': 2.1e-0_5,
									            '''token''': 2_55_06,
									            '''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-0_5, '''token''': 1_36_06, '''token_str''': ''' Clara'''},
									        {'''sequence''': '''My name is Patrick''', '''score''': 2e-0_5, '''token''': 34_99, '''token_str''': ''' Patrick'''},
									        {'''sequence''': '''My name is Te''', '''score''': 1.9e-0_5, '''token''': 29_41, '''token_str''': ''' Te'''},
									    ]							,							)

							@require_torch
							def _lowercase       (self     ):

									"""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-0_5, '''token''': 3_56_76, '''token_str''': ''' Maul'''},
									        {'''sequence''': '''My name isELS''', '''score''': 2.2e-0_5, '''token''': 1_64_16, '''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-0_5,
									            '''token''': 3_56_76,
									            '''token_str''': ''' Maul''',
									        },
									        {'''sequence''': '''The largest city in France isELS''', '''score''': 2.2e-0_5, '''token''': 1_64_16, '''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-0_5, '''token''': 34_99, '''token_str''': ''' Patrick'''},
									        {'''sequence''': '''My name is Te''', '''score''': 2e-0_5, '''token''': 29_41, '''token_str''': ''' Te'''},
									        {'''sequence''': '''My name is Clara''', '''score''': 2e-0_5, '''token''': 1_36_06, '''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-0_5,
									                '''token''': 3_56_76,
									                '''token_str''': ''' Maul''',
									                '''sequence''': '''<s>My name is Maul<mask></s>''',
									            },
									            {'''score''': 2.2e-0_5, '''token''': 1_64_16, '''token_str''': '''ELS''', '''sequence''': '''<s>My name isELS<mask></s>'''},
									        ],
									        [
									            {
									                '''score''': 2.2e-0_5,
									                '''token''': 3_56_76,
									                '''token_str''': ''' Maul''',
									                '''sequence''': '''<s>My name is<mask> Maul</s>''',
									            },
									            {'''score''': 2.2e-0_5, '''token''': 1_64_16, '''token_str''': '''ELS''', '''sequence''': '''<s>My name is<mask>ELS</s>'''},
									        ],
									    ]							,							)

							@require_torch_gpu
							def _lowercase       (self     ):

									"""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 _lowercase       (self     ):

									"""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 _lowercase       (self     ):

									"""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 _lowercase       (self							,							SCREAMING_SNAKE_CASE_     ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_    			=			unmasker('''My name is <mask>'''     )
									self.assertEqual(
									    nested_simplify(SCREAMING_SNAKE_CASE_     )							,							[
									        {'''sequence''': '''My name is John''', '''score''': 0.0_08, '''token''': 6_10, '''token_str''': ''' John'''},
									        {'''sequence''': '''My name is Chris''', '''score''': 0.0_07, '''token''': 15_73, '''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.2_51,
									            '''token''': 22_01,
									            '''token_str''': ''' Paris''',
									        },
									        {
									            '''sequence''': '''The largest city in France is Lyon''',
									            '''score''': 0.2_14,
									            '''token''': 1_27_90,
									            '''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.0_05, '''token''': 34_99, '''token_str''': ''' Patrick'''},
									        {'''sequence''': '''My name is Clara''', '''score''': 0.0_00, '''token''': 1_36_06, '''token_str''': ''' Clara'''},
									        {'''sequence''': '''My name is Te''', '''score''': 0.0_00, '''token''': 29_41, '''token_str''': ''' Te'''},
									    ]							,							)

							@require_torch
							def _lowercase       (self     ):

									"""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 _lowercase       (self     ):

									"""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 _lowercase       (self							,							SCREAMING_SNAKE_CASE_							,							SCREAMING_SNAKE_CASE_							,							SCREAMING_SNAKE_CASE_     ):

									"""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 _lowercase       (self							,							SCREAMING_SNAKE_CASE_							,							SCREAMING_SNAKE_CASE_     ):

									"""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 _lowercase       (self							,							SCREAMING_SNAKE_CASE_							,							SCREAMING_SNAKE_CASE_     ):

									"""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 _lowercase       (self							,							SCREAMING_SNAKE_CASE_							,							SCREAMING_SNAKE_CASE_     ):

									"""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 _lowercase       (self							,							SCREAMING_SNAKE_CASE_							,							SCREAMING_SNAKE_CASE_     ):

									"""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 _lowercase       (self							,							SCREAMING_SNAKE_CASE_							,							SCREAMING_SNAKE_CASE_     ):

									"""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 _lowercase       (self							,							SCREAMING_SNAKE_CASE_							,							SCREAMING_SNAKE_CASE_     ):

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




from __future__ import annotations

from collections.abc import Callable



def 							_lowerCamelCase			(			__a,				__a,				__a,				__a = 100,				):
		SCREAMING_SNAKE_CASE_    			=			x_start
		SCREAMING_SNAKE_CASE_    			=			fnc(__a     )
		SCREAMING_SNAKE_CASE_    			=			0.0
		for _ in range(__a     ):
				# Approximates small segments of curve as linear and solve
				# for trapezoidal area
				SCREAMING_SNAKE_CASE_    			=			(x_end - x_start) / steps + xa
				SCREAMING_SNAKE_CASE_    			=			fnc(__a     )
				area += abs(fxa + fxa     ) * (xa - xa) / 2
				# Increment step
				SCREAMING_SNAKE_CASE_    			=			xa
				SCREAMING_SNAKE_CASE_    			=			fxa
		return area


if __name__ == "__main__":



						def 							_lowerCamelCase			(			__a     ):
								return x**3 + x**2

						print('f(x) = x^3 + x^2')
						print('The area between the curve, x = -5, x = 5 and the x axis is:')
						lowerCAmelCase__				=					10
						while i <= 100000:
												print(f'''with {i} steps: {trapezoidal_area(f, -5, 5, i)}''')
												i *= 10