


"""simple docstring"""






import gc
import unittest

from transformers import MODEL_FOR_MASKED_LM_MAPPING, TF_MODEL_FOR_MASKED_LM_MAPPING, FillMaskPipeline, pipeline
from transformers.pipelines import PipelineException
from transformers.testing_utils import (
    is_pipeline_test,
    is_torch_available,
    nested_simplify,
    require_tf,
    require_torch,
    require_torch_gpu,
    slow,
)

from .test_pipelines_common import ANY





@is_pipeline_test
class      lowerCamelCase__   (     unittest.TestCase				):







					"""simple docstring"""


					__a	       =							MODEL_FOR_MASKED_LM_MAPPING
					__a	       =							TF_MODEL_FOR_MASKED_LM_MAPPING






					def lowerCamelCase__							(       self    : List[str]  ):
												'''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 lowerCamelCase__							(       self    : List[str]  ):
												'''simple docstring'''






												__UpperCAmelCase   :						List[str]      							=					pipeline(task="""fill-mask""" ,       model="""sshleifer/tiny-distilroberta-base""" ,       top_k=2 ,       framework="""tf"""  )
												__UpperCAmelCase   :						List[str]      							=					unmasker("""My name is <mask>"""  )
												self.assertEqual(
												    nested_simplify(UpperCamelCase ,       decimals=6  ) ,       [
												        {"""sequence""": """My name is grouped""", """score""": 2.1e-0_5, """token""": 38_015, """token_str""": """ grouped"""},
												        {"""sequence""": """My name is accuser""", """score""": 2.1e-0_5, """token""": 25_506, """token_str""": """ accuser"""},
												    ] ,       )

												__UpperCAmelCase   :						Dict      							=					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-0_5,
												            """token""": 38_015,
												            """token_str""": """ grouped""",
												        },
												        {
												            """sequence""": """The largest city in France is accuser""",
												            """score""": 2.1e-0_5,
												            """token""": 25_506,
												            """token_str""": """ accuser""",
												        },
												    ] ,       )

												__UpperCAmelCase   :						Optional[Any]      							=					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-0_5, """token""": 13_606, """token_str""": """ Clara"""},
												        {"""sequence""": """My name is Patrick""", """score""": 2e-0_5, """token""": 3_499, """token_str""": """ Patrick"""},
												        {"""sequence""": """My name is Te""", """score""": 1.9e-0_5, """token""": 2_941, """token_str""": """ Te"""},
												    ] ,       )






					@require_torch
					def lowerCamelCase__							(       self    : List[Any]  ):
												'''simple docstring'''






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

												__UpperCAmelCase   :						List[Any]      							=					unmasker("""My name is <mask>"""  )
												self.assertEqual(
												    nested_simplify(UpperCamelCase ,       decimals=6  ) ,       [
												        {"""sequence""": """My name is Maul""", """score""": 2.2e-0_5, """token""": 35_676, """token_str""": """ Maul"""},
												        {"""sequence""": """My name isELS""", """score""": 2.2e-0_5, """token""": 16_416, """token_str""": """ELS"""},
												    ] ,       )

												__UpperCAmelCase   :						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-0_5,
												            """token""": 35_676,
												            """token_str""": """ Maul""",
												        },
												        {"""sequence""": """The largest city in France isELS""", """score""": 2.2e-0_5, """token""": 16_416, """token_str""": """ELS"""},
												    ] ,       )

												__UpperCAmelCase   :						Union[str, Any]      							=					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-0_5, """token""": 3_499, """token_str""": """ Patrick"""},
												        {"""sequence""": """My name is Te""", """score""": 2e-0_5, """token""": 2_941, """token_str""": """ Te"""},
												        {"""sequence""": """My name is Clara""", """score""": 2e-0_5, """token""": 13_606, """token_str""": """ Clara"""},
												    ] ,       )

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

												self.assertEqual(
												    nested_simplify(UpperCamelCase ,       decimals=6  ) ,       [
												        [
												            {
												                """score""": 2.2e-0_5,
												                """token""": 35_676,
												                """token_str""": """ Maul""",
												                """sequence""": """<s>My name is Maul<mask></s>""",
												            },
												            {"""score""": 2.2e-0_5, """token""": 16_416, """token_str""": """ELS""", """sequence""": """<s>My name isELS<mask></s>"""},
												        ],
												        [
												            {
												                """score""": 2.2e-0_5,
												                """token""": 35_676,
												                """token_str""": """ Maul""",
												                """sequence""": """<s>My name is<mask> Maul</s>""",
												            },
												            {"""score""": 2.2e-0_5, """token""": 16_416, """token_str""": """ELS""", """sequence""": """<s>My name is<mask>ELS</s>"""},
												        ],
												    ] ,       )






					@require_torch_gpu
					def lowerCamelCase__							(       self    : int  ):
												'''simple docstring'''






												__UpperCAmelCase   :						List[Any]      							=					pipeline("""fill-mask""" ,       model="""hf-internal-testing/tiny-random-distilbert""" ,       device=0 ,       framework="""pt"""  )

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

												__UpperCAmelCase   :						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(UpperCamelCase ,       UpperCamelCase  )






					@slow
					@require_torch
					def lowerCamelCase__							(       self    : Any  ):
												'''simple docstring'''






												__UpperCAmelCase   :						List[str]      							=					pipeline(task="""fill-mask""" ,       model="""distilroberta-base""" ,       top_k=2 ,       framework="""pt"""  )
												self.run_large_test(UpperCamelCase  )






					@slow
					@require_tf
					def lowerCamelCase__							(       self    : Tuple  ):
												'''simple docstring'''






												__UpperCAmelCase   :						Optional[int]      							=					pipeline(task="""fill-mask""" ,       model="""distilroberta-base""" ,       top_k=2 ,       framework="""tf"""  )
												self.run_large_test(UpperCamelCase  )






					def lowerCamelCase__							(       self    : List[Any] ,       UpperCamelCase    : Optional[Any]  ):
												'''simple docstring'''






												__UpperCAmelCase   :						str      							=					unmasker("""My name is <mask>"""  )
												self.assertEqual(
												    nested_simplify(UpperCamelCase  ) ,       [
												        {"""sequence""": """My name is John""", """score""": 0.008, """token""": 610, """token_str""": """ John"""},
												        {"""sequence""": """My name is Chris""", """score""": 0.007, """token""": 1_573, """token_str""": """ Chris"""},
												    ] ,       )
												__UpperCAmelCase   :						Tuple      							=					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""": 2_201,
												            """token_str""": """ Paris""",
												        },
												        {
												            """sequence""": """The largest city in France is Lyon""",
												            """score""": 0.214,
												            """token""": 12_790,
												            """token_str""": """ Lyon""",
												        },
												    ] ,       )

												__UpperCAmelCase   :						int      							=					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""": 3_499, """token_str""": """ Patrick"""},
												        {"""sequence""": """My name is Clara""", """score""": 0.000, """token""": 13_606, """token_str""": """ Clara"""},
												        {"""sequence""": """My name is Te""", """score""": 0.000, """token""": 2_941, """token_str""": """ Te"""},
												    ] ,       )






					@require_torch
					def lowerCamelCase__							(       self    : List[Any]  ):
												'''simple docstring'''






												__UpperCAmelCase   :						Tuple      							=					pipeline(task="""fill-mask""" ,       model="""sshleifer/tiny-distilroberta-base""" ,       framework="""pt"""  )
												__UpperCAmelCase   :						Optional[int]      							=					None
												__UpperCAmelCase   :						Tuple      							=					None
												self.run_pipeline_test(UpperCamelCase ,       []  )






					@require_tf
					def lowerCamelCase__							(       self    : int  ):
												'''simple docstring'''






												__UpperCAmelCase   :						Any      							=					pipeline(task="""fill-mask""" ,       model="""sshleifer/tiny-distilroberta-base""" ,       framework="""tf"""  )
												__UpperCAmelCase   :						List[str]      							=					None
												__UpperCAmelCase   :						Union[str, Any]      							=					None
												self.run_pipeline_test(UpperCamelCase ,       []  )






					def lowerCamelCase__							(       self    : Optional[Any] ,       UpperCamelCase    : int ,       UpperCamelCase    : Tuple ,       UpperCamelCase    : 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)"""  )

												__UpperCAmelCase   :						Union[str, Any]      							=					FillMaskPipeline(model=UpperCamelCase ,       tokenizer=UpperCamelCase  )
												__UpperCAmelCase   :						Tuple      							=					[
												    f'''This is another {tokenizer.mask_token} test''',
												]
												return fill_masker, examples






					def lowerCamelCase__							(       self    : int ,       UpperCamelCase    : Tuple ,       UpperCamelCase    : Union[str, Any]  ):
												'''simple docstring'''






												__UpperCAmelCase   :						List[str]      							=					fill_masker.tokenizer
												__UpperCAmelCase   :						Union[str, Any]      							=					fill_masker.model

												__UpperCAmelCase   :						Dict      							=					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  )},
												    ] ,       )

												__UpperCAmelCase   :						Optional[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  )},
												        {"""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  )},
												    ] ,       )

												__UpperCAmelCase   :						Union[str, 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 lowerCamelCase__							(       self    : str ,       UpperCamelCase    : Any ,       UpperCamelCase    : Optional[int]  ):
												'''simple docstring'''






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

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

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

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






					def lowerCamelCase__							(       self    : Union[str, Any] ,       UpperCamelCase    : Optional[Any] ,       UpperCamelCase    : int  ):
												'''simple docstring'''






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

												__UpperCAmelCase   :						Any      							=					FillMaskPipeline(model=UpperCamelCase ,       tokenizer=UpperCamelCase  )
												__UpperCAmelCase   :						List[Any]      							=					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 lowerCamelCase__							(       self    : List[Any] ,       UpperCamelCase    : Optional[int] ,       UpperCamelCase    : Union[str, Any]  ):
												'''simple docstring'''






												__UpperCAmelCase   :						Optional[int]      							=					tokenizer.get_vocab()
												__UpperCAmelCase   :						Optional[Any]      							=					FillMaskPipeline(model=UpperCamelCase ,       tokenizer=UpperCamelCase  )

												# top_k=2, ntargets=3
												__UpperCAmelCase   :						Union[str, Any]      							=					sorted(vocab.keys()  )[:3]
												__UpperCAmelCase   :						int      							=					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
												__UpperCAmelCase   :						str      							=					[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  ):
																			__UpperCAmelCase   :						Optional[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 lowerCamelCase__							(       self    : str ,       UpperCamelCase    : str ,       UpperCamelCase    : Any  ):
												'''simple docstring'''






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






												__UpperCAmelCase   :						Optional[Any]      							=					FillMaskPipeline(model=UpperCamelCase ,       tokenizer=UpperCamelCase  )

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




"""simple docstring"""






import math
def      lowerCamelCase       (     _UpperCamelCase		:      int							)		->       list[int]:

							'''simple docstring'''



							__UpperCAmelCase   :						List[Any]      							=					[]
							__UpperCAmelCase   :						Dict      							=					2
							__UpperCAmelCase   :						Union[str, Any]      							=					int(math.sqrt(_UpperCamelCase							)							)  # Size of every segment
							__UpperCAmelCase   :						Tuple      							=					[True] * (end + 1)
							__UpperCAmelCase   :						int      							=					[]

							while start <= end:
														if temp[start] is True:
																					in_prime.append(_UpperCamelCase							)
																					for i in range(start * start       ,			end + 1       ,			_UpperCamelCase							):
																												__UpperCAmelCase   :						Dict      							=					False
														start += 1
							prime += in_prime

							__UpperCAmelCase   :						Optional[int]      							=					end + 1
							__UpperCAmelCase   :						Dict      							=					min(2 * end       ,			_UpperCamelCase							)

							while low <= n:
														__UpperCAmelCase   :						Union[str, Any]      							=					[True] * (high - low + 1)
														for each in in_prime:
																					__UpperCAmelCase   :						Dict      							=					math.floor(low / each							) * each
																					if t < low:
																												t += each

																					for j in range(_UpperCamelCase       ,			high + 1       ,			_UpperCamelCase							):
																												__UpperCAmelCase   :						Tuple      							=					False

														for j in range(len(_UpperCamelCase							)							):
																					if temp[j] is True:
																												prime.append(j + low							)

														__UpperCAmelCase   :						Tuple      							=					high + 1
														__UpperCAmelCase   :						Optional[int]      							=					min(high + end       ,			_UpperCamelCase							)

							return prime
print(sieve(10**6))
