


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 						_UpperCAmelCase      (     unittest.TestCase							):
		lowerCamelCase_	:			Dict       			=  MODEL_FOR_MASKED_LM_MAPPING
		lowerCamelCase_	:			int       			=  TF_MODEL_FOR_MASKED_LM_MAPPING






		def _snake_case		(						self				:     Optional[Any]):
				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 _snake_case		(						self				:     str):
				SCREAMING_SNAKE_CASE_				:Dict				     =						pipeline(task="fill-mask"   ,  model="sshleifer/tiny-distilroberta-base"   ,  top_k=2   ,  framework="tf")
				SCREAMING_SNAKE_CASE_				:Dict				     =						unmasker("My name is <mask>")
				self.assertEqual(
				    nested_simplify(UpperCAmelCase   ,  decimals=6)   ,  [
				        {"sequence": "My name is grouped", "score": 2.1E-05, "token": 3_80_15, "token_str": " grouped"},
				        {"sequence": "My name is accuser", "score": 2.1E-05, "token": 2_55_06, "token_str": " accuser"},
				    ]   ,  )

				SCREAMING_SNAKE_CASE_				:Any				     =						unmasker("The largest city in France is <mask>")
				self.assertEqual(
				    nested_simplify(UpperCAmelCase   ,  decimals=6)   ,  [
				        {
				            "sequence": "The largest city in France is grouped",
				            "score": 2.1E-05,
				            "token": 3_80_15,
				            "token_str": " grouped",
				        },
				        {
				            "sequence": "The largest city in France is accuser",
				            "score": 2.1E-05,
				            "token": 2_55_06,
				            "token_str": " accuser",
				        },
				    ]   ,  )

				SCREAMING_SNAKE_CASE_				:Tuple				     =						unmasker("My name is <mask>"   ,  targets=[" Patrick", " Clara", " Teven"]   ,  top_k=3)
				self.assertEqual(
				    nested_simplify(UpperCAmelCase   ,  decimals=6)   ,  [
				        {"sequence": "My name is Clara", "score": 2E-05, "token": 1_36_06, "token_str": " Clara"},
				        {"sequence": "My name is Patrick", "score": 2E-05, "token": 34_99, "token_str": " Patrick"},
				        {"sequence": "My name is Te", "score": 1.9E-05, "token": 29_41, "token_str": " Te"},
				    ]   ,  )






		@require_torch
		def _snake_case		(						self				:     List[str]):
				SCREAMING_SNAKE_CASE_				:int				     =						pipeline(task="fill-mask"   ,  model="sshleifer/tiny-distilroberta-base"   ,  top_k=2   ,  framework="pt")

				SCREAMING_SNAKE_CASE_				:List[Any]				     =						unmasker("My name is <mask>")
				self.assertEqual(
				    nested_simplify(UpperCAmelCase   ,  decimals=6)   ,  [
				        {"sequence": "My name is Maul", "score": 2.2E-05, "token": 3_56_76, "token_str": " Maul"},
				        {"sequence": "My name isELS", "score": 2.2E-05, "token": 1_64_16, "token_str": "ELS"},
				    ]   ,  )

				SCREAMING_SNAKE_CASE_				:Any				     =						unmasker("The largest city in France is <mask>")
				self.assertEqual(
				    nested_simplify(UpperCAmelCase   ,  decimals=6)   ,  [
				        {
				            "sequence": "The largest city in France is Maul",
				            "score": 2.2E-05,
				            "token": 3_56_76,
				            "token_str": " Maul",
				        },
				        {"sequence": "The largest city in France isELS", "score": 2.2E-05, "token": 1_64_16, "token_str": "ELS"},
				    ]   ,  )

				SCREAMING_SNAKE_CASE_				:Optional[int]				     =						unmasker("My name is <mask>"   ,  targets=[" Patrick", " Clara", " Teven"]   ,  top_k=3)
				self.assertEqual(
				    nested_simplify(UpperCAmelCase   ,  decimals=6)   ,  [
				        {"sequence": "My name is Patrick", "score": 2.1E-05, "token": 34_99, "token_str": " Patrick"},
				        {"sequence": "My name is Te", "score": 2E-05, "token": 29_41, "token_str": " Te"},
				        {"sequence": "My name is Clara", "score": 2E-05, "token": 1_36_06, "token_str": " Clara"},
				    ]   ,  )

				SCREAMING_SNAKE_CASE_				:str				     =						unmasker("My name is <mask> <mask>"   ,  top_k=2)

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






		@require_torch_gpu
		def _snake_case		(						self				:     str):
				SCREAMING_SNAKE_CASE_				:List[Any]				     =						pipeline("fill-mask"   ,  model="hf-internal-testing/tiny-random-distilbert"   ,  device=0   ,  framework="pt")

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

				SCREAMING_SNAKE_CASE_				:Dict				     =						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(UpperCAmelCase   ,  UpperCAmelCase)






		@slow
		@require_torch
		def _snake_case		(						self				:     int):
				SCREAMING_SNAKE_CASE_				:Union[str, Any]				     =						pipeline(task="fill-mask"   ,  model="distilroberta-base"   ,  top_k=2   ,  framework="pt")
				self.run_large_test(UpperCAmelCase)






		@slow
		@require_tf
		def _snake_case		(						self				:     int):
				SCREAMING_SNAKE_CASE_				:str				     =						pipeline(task="fill-mask"   ,  model="distilroberta-base"   ,  top_k=2   ,  framework="tf")
				self.run_large_test(UpperCAmelCase)






		def _snake_case		(						self				:     Dict   ,  UpperCAmelCase				:     List[Any]):
				SCREAMING_SNAKE_CASE_				:int				     =						unmasker("My name is <mask>")
				self.assertEqual(
				    nested_simplify(UpperCAmelCase)   ,  [
				        {"sequence": "My name is John", "score": 0.008, "token": 6_10, "token_str": " John"},
				        {"sequence": "My name is Chris", "score": 0.007, "token": 15_73, "token_str": " Chris"},
				    ]   ,  )
				SCREAMING_SNAKE_CASE_				:List[str]				     =						unmasker("The largest city in France is <mask>")
				self.assertEqual(
				    nested_simplify(UpperCAmelCase)   ,  [
				        {
				            "sequence": "The largest city in France is Paris",
				            "score": 0.251,
				            "token": 22_01,
				            "token_str": " Paris",
				        },
				        {
				            "sequence": "The largest city in France is Lyon",
				            "score": 0.214,
				            "token": 1_27_90,
				            "token_str": " Lyon",
				        },
				    ]   ,  )

				SCREAMING_SNAKE_CASE_				:Union[str, Any]				     =						unmasker("My name is <mask>"   ,  targets=[" Patrick", " Clara", " Teven"]   ,  top_k=3)
				self.assertEqual(
				    nested_simplify(UpperCAmelCase)   ,  [
				        {"sequence": "My name is Patrick", "score": 0.005, "token": 34_99, "token_str": " Patrick"},
				        {"sequence": "My name is Clara", "score": 0.000, "token": 1_36_06, "token_str": " Clara"},
				        {"sequence": "My name is Te", "score": 0.000, "token": 29_41, "token_str": " Te"},
				    ]   ,  )






		@require_torch
		def _snake_case		(						self				:     Optional[int]):
				SCREAMING_SNAKE_CASE_				:List[Any]				     =						pipeline(task="fill-mask"   ,  model="sshleifer/tiny-distilroberta-base"   ,  framework="pt")
				SCREAMING_SNAKE_CASE_				:int				     =						None
				SCREAMING_SNAKE_CASE_				:Tuple				     =						None
				self.run_pipeline_test(UpperCAmelCase   ,  [])






		@require_tf
		def _snake_case		(						self				:     Any):
				SCREAMING_SNAKE_CASE_				:Any				     =						pipeline(task="fill-mask"   ,  model="sshleifer/tiny-distilroberta-base"   ,  framework="tf")
				SCREAMING_SNAKE_CASE_				:str				     =						None
				SCREAMING_SNAKE_CASE_				:Tuple				     =						None
				self.run_pipeline_test(UpperCAmelCase   ,  [])






		def _snake_case		(						self				:     str   ,  UpperCAmelCase				:     Optional[int]   ,  UpperCAmelCase				:     str   ,  UpperCAmelCase				:     Dict):
				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_				:Any				     =						FillMaskPipeline(model=UpperCAmelCase   ,  tokenizer=UpperCAmelCase)
				SCREAMING_SNAKE_CASE_				:List[Any]				     =						[
				    F"This is another {tokenizer.mask_token} test",
				]
				return fill_masker, examples






		def _snake_case		(						self				:     Any   ,  UpperCAmelCase				:     List[Any]   ,  UpperCAmelCase				:     str):
				SCREAMING_SNAKE_CASE_				:Optional[int]				     =						fill_masker.tokenizer
				SCREAMING_SNAKE_CASE_				:List[Any]				     =						fill_masker.model

				SCREAMING_SNAKE_CASE_				:List[str]				     =						fill_masker(
				    F"This is a {tokenizer.mask_token}"   ,  )
				self.assertEqual(
				    UpperCAmelCase   ,  [
				        {"sequence": ANY(UpperCAmelCase), "score": ANY(UpperCAmelCase), "token": ANY(UpperCAmelCase), "token_str": ANY(UpperCAmelCase)},
				        {"sequence": ANY(UpperCAmelCase), "score": ANY(UpperCAmelCase), "token": ANY(UpperCAmelCase), "token_str": ANY(UpperCAmelCase)},
				        {"sequence": ANY(UpperCAmelCase), "score": ANY(UpperCAmelCase), "token": ANY(UpperCAmelCase), "token_str": ANY(UpperCAmelCase)},
				        {"sequence": ANY(UpperCAmelCase), "score": ANY(UpperCAmelCase), "token": ANY(UpperCAmelCase), "token_str": ANY(UpperCAmelCase)},
				        {"sequence": ANY(UpperCAmelCase), "score": ANY(UpperCAmelCase), "token": ANY(UpperCAmelCase), "token_str": ANY(UpperCAmelCase)},
				    ]   ,  )

				SCREAMING_SNAKE_CASE_				:Tuple				     =						fill_masker([F"This is a {tokenizer.mask_token}"])
				self.assertEqual(
				    UpperCAmelCase   ,  [
				        {"sequence": ANY(UpperCAmelCase), "score": ANY(UpperCAmelCase), "token": ANY(UpperCAmelCase), "token_str": ANY(UpperCAmelCase)},
				        {"sequence": ANY(UpperCAmelCase), "score": ANY(UpperCAmelCase), "token": ANY(UpperCAmelCase), "token_str": ANY(UpperCAmelCase)},
				        {"sequence": ANY(UpperCAmelCase), "score": ANY(UpperCAmelCase), "token": ANY(UpperCAmelCase), "token_str": ANY(UpperCAmelCase)},
				        {"sequence": ANY(UpperCAmelCase), "score": ANY(UpperCAmelCase), "token": ANY(UpperCAmelCase), "token_str": ANY(UpperCAmelCase)},
				        {"sequence": ANY(UpperCAmelCase), "score": ANY(UpperCAmelCase), "token": ANY(UpperCAmelCase), "token_str": ANY(UpperCAmelCase)},
				    ]   ,  )

				SCREAMING_SNAKE_CASE_				:Any				     =						fill_masker([F"This is a {tokenizer.mask_token}", F"Another {tokenizer.mask_token} great test."])
				self.assertEqual(
				    UpperCAmelCase   ,  [
				        [
				            {"sequence": ANY(UpperCAmelCase), "score": ANY(UpperCAmelCase), "token": ANY(UpperCAmelCase), "token_str": ANY(UpperCAmelCase)},
				            {"sequence": ANY(UpperCAmelCase), "score": ANY(UpperCAmelCase), "token": ANY(UpperCAmelCase), "token_str": ANY(UpperCAmelCase)},
				            {"sequence": ANY(UpperCAmelCase), "score": ANY(UpperCAmelCase), "token": ANY(UpperCAmelCase), "token_str": ANY(UpperCAmelCase)},
				            {"sequence": ANY(UpperCAmelCase), "score": ANY(UpperCAmelCase), "token": ANY(UpperCAmelCase), "token_str": ANY(UpperCAmelCase)},
				            {"sequence": ANY(UpperCAmelCase), "score": ANY(UpperCAmelCase), "token": ANY(UpperCAmelCase), "token_str": ANY(UpperCAmelCase)},
				        ],
				        [
				            {"sequence": ANY(UpperCAmelCase), "score": ANY(UpperCAmelCase), "token": ANY(UpperCAmelCase), "token_str": ANY(UpperCAmelCase)},
				            {"sequence": ANY(UpperCAmelCase), "score": ANY(UpperCAmelCase), "token": ANY(UpperCAmelCase), "token_str": ANY(UpperCAmelCase)},
				            {"sequence": ANY(UpperCAmelCase), "score": ANY(UpperCAmelCase), "token": ANY(UpperCAmelCase), "token_str": ANY(UpperCAmelCase)},
				            {"sequence": ANY(UpperCAmelCase), "score": ANY(UpperCAmelCase), "token": ANY(UpperCAmelCase), "token_str": ANY(UpperCAmelCase)},
				            {"sequence": ANY(UpperCAmelCase), "score": ANY(UpperCAmelCase), "token": ANY(UpperCAmelCase), "token_str": ANY(UpperCAmelCase)},
				        ],
				    ]   ,  )

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

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






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

				# Call argument
				SCREAMING_SNAKE_CASE_				:Any				     =						FillMaskPipeline(model=UpperCAmelCase   ,  tokenizer=UpperCAmelCase)
				SCREAMING_SNAKE_CASE_				:List[str]				     =						fill_masker(F"This is a {tokenizer.mask_token}"   ,  targets=UpperCAmelCase)
				self.assertEqual(
				    UpperCAmelCase   ,  [
				        {"sequence": ANY(UpperCAmelCase), "score": ANY(UpperCAmelCase), "token": ANY(UpperCAmelCase), "token_str": ANY(UpperCAmelCase)},
				        {"sequence": ANY(UpperCAmelCase), "score": ANY(UpperCAmelCase), "token": ANY(UpperCAmelCase), "token_str": ANY(UpperCAmelCase)},
				    ]   ,  )
				SCREAMING_SNAKE_CASE_				:Dict				     =						{vocab[el] for el in targets}
				self.assertEqual({el["token"] for el in outputs}   ,  UpperCAmelCase)
				SCREAMING_SNAKE_CASE_				:Dict				     =						[tokenizer.decode([x]) for x in target_ids]
				self.assertEqual({el["token_str"] for el in outputs}   ,  set(UpperCAmelCase))

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

				# Raises with invalid
				with self.assertRaises(UpperCAmelCase):
						SCREAMING_SNAKE_CASE_				:str				     =						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(UpperCAmelCase):
								SCREAMING_SNAKE_CASE_				:Tuple				     =						fill_masker(F"This is a {tokenizer.mask_token}"   ,  targets=[""])
						with self.assertRaises(UpperCAmelCase):
								SCREAMING_SNAKE_CASE_				:Union[str, Any]				     =						fill_masker(F"This is a {tokenizer.mask_token}"   ,  targets="")






		def _snake_case		(						self				:     Dict   ,  UpperCAmelCase				:     List[str]   ,  UpperCAmelCase				:     Union[str, Any]):
				SCREAMING_SNAKE_CASE_				:Optional[Any]				     =						FillMaskPipeline(model=UpperCAmelCase   ,  tokenizer=UpperCAmelCase   ,  top_k=2)
				SCREAMING_SNAKE_CASE_				:List[Any]				     =						fill_masker(F"This is a {tokenizer.mask_token}")
				self.assertEqual(
				    UpperCAmelCase   ,  [
				        {"sequence": ANY(UpperCAmelCase), "score": ANY(UpperCAmelCase), "token": ANY(UpperCAmelCase), "token_str": ANY(UpperCAmelCase)},
				        {"sequence": ANY(UpperCAmelCase), "score": ANY(UpperCAmelCase), "token": ANY(UpperCAmelCase), "token_str": ANY(UpperCAmelCase)},
				    ]   ,  )

				SCREAMING_SNAKE_CASE_				:List[str]				     =						FillMaskPipeline(model=UpperCAmelCase   ,  tokenizer=UpperCAmelCase)
				SCREAMING_SNAKE_CASE_				:Optional[int]				     =						fill_masker(F"This is a {tokenizer.mask_token}"   ,  top_k=2)
				self.assertEqual(
				    UpperCAmelCase   ,  [
				        {"sequence": ANY(UpperCAmelCase), "score": ANY(UpperCAmelCase), "token": ANY(UpperCAmelCase), "token_str": ANY(UpperCAmelCase)},
				        {"sequence": ANY(UpperCAmelCase), "score": ANY(UpperCAmelCase), "token": ANY(UpperCAmelCase), "token_str": ANY(UpperCAmelCase)},
				    ]   ,  )
				self.assertEqual(nested_simplify(UpperCAmelCase)   ,  nested_simplify(UpperCAmelCase))






		def _snake_case		(						self				:     List[str]   ,  UpperCAmelCase				:     List[str]   ,  UpperCAmelCase				:     List[str]):
				SCREAMING_SNAKE_CASE_				:Optional[int]				     =						tokenizer.get_vocab()
				SCREAMING_SNAKE_CASE_				:Union[str, Any]				     =						FillMaskPipeline(model=UpperCAmelCase   ,  tokenizer=UpperCAmelCase)

				# top_k=2, ntargets=3
				SCREAMING_SNAKE_CASE_				:Any				     =						sorted(vocab.keys())[:3]
				SCREAMING_SNAKE_CASE_				:Any				     =						fill_masker(F"This is a {tokenizer.mask_token}"   ,  top_k=2   ,  targets=UpperCAmelCase)

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






		def _snake_case		(						self				:     int   ,  UpperCAmelCase				:     Optional[Any]   ,  UpperCAmelCase				:     Optional[Any]):
				SCREAMING_SNAKE_CASE_				:Tuple				     =						FillMaskPipeline(model=UpperCAmelCase   ,  tokenizer=UpperCAmelCase)
				SCREAMING_SNAKE_CASE_				:Union[str, Any]				     =						tokenizer.get_vocab()
				# String duplicates + id duplicates
				SCREAMING_SNAKE_CASE_				:List[Any]				     =						sorted(vocab.keys())[:3]
				SCREAMING_SNAKE_CASE_				:Tuple				     =						[targets[0], targets[1], targets[0], targets[2], targets[1]]
				SCREAMING_SNAKE_CASE_				:Tuple				     =						fill_masker(F"My name is {tokenizer.mask_token}"   ,  targets=UpperCAmelCase   ,  top_k=10)

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







		def _snake_case		(						self				:     int   ,  UpperCAmelCase				:     str   ,  UpperCAmelCase				:     List[Any]):
				SCREAMING_SNAKE_CASE_				:List[Any]				     =						FillMaskPipeline(model=UpperCAmelCase   ,  tokenizer=UpperCAmelCase)

				SCREAMING_SNAKE_CASE_				:Union[str, Any]				     =						fill_masker(
				    F"This is a {tokenizer.mask_token} {tokenizer.mask_token} {tokenizer.mask_token}"   ,  top_k=2)
				self.assertEqual(
				    UpperCAmelCase   ,  [
				        [
				            {"sequence": ANY(UpperCAmelCase), "score": ANY(UpperCAmelCase), "token": ANY(UpperCAmelCase), "token_str": ANY(UpperCAmelCase)},
				            {"sequence": ANY(UpperCAmelCase), "score": ANY(UpperCAmelCase), "token": ANY(UpperCAmelCase), "token_str": ANY(UpperCAmelCase)},
				        ],
				        [
				            {"sequence": ANY(UpperCAmelCase), "score": ANY(UpperCAmelCase), "token": ANY(UpperCAmelCase), "token_str": ANY(UpperCAmelCase)},
				            {"sequence": ANY(UpperCAmelCase), "score": ANY(UpperCAmelCase), "token": ANY(UpperCAmelCase), "token_str": ANY(UpperCAmelCase)},
				        ],
				        [
				            {"sequence": ANY(UpperCAmelCase), "score": ANY(UpperCAmelCase), "token": ANY(UpperCAmelCase), "token_str": ANY(UpperCAmelCase)},
				            {"sequence": ANY(UpperCAmelCase), "score": ANY(UpperCAmelCase), "token": ANY(UpperCAmelCase), "token_str": ANY(UpperCAmelCase)},
				        ],
				    ]   ,  )










def     lowercase	(    a = 50 ):



		'''simple docstring'''




		SCREAMING_SNAKE_CASE_				:int				     =						[1] * (length + 1)

		for row_length in range(3     , length + 1 ):
				for block_length in range(3     , row_length + 1 ):
						for block_start in range(row_length - block_length ):
								ways_number[row_length] += ways_number[
								    row_length - block_start - block_length - 1
								]

						ways_number[row_length] += 1

		return ways_number[length]


if __name__ == "__main__":
		print(F'''{solution() = }''')






