






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





	"""simple docstring"""




	_A							:					Union[str, Any] 			=					MODEL_FOR_MASKED_LM_MAPPING
	_A							:					List[Any] 			=					TF_MODEL_FOR_MASKED_LM_MAPPING





	def  lowerCamelCase(self				):
		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				):
		A_		:    Optional[Any]						     = pipeline(task="""fill-mask"""  ,  model="""sshleifer/tiny-distilroberta-base"""  ,  top_k=2  ,  framework="""tf"""				)
		A_		:    Optional[int]						     = unmasker("""My name is <mask>"""				)
		self.assertEqual(
		    nested_simplify(lowerCAmelCase_  ,  decimals=6				)  ,  [
		        {"""sequence""": """My name is grouped""", """score""": 2.1e-0_5, """token""": 38015, """token_str""": """ grouped"""},
		        {"""sequence""": """My name is accuser""", """score""": 2.1e-0_5, """token""": 25506, """token_str""": """ accuser"""},
		    ]  ,  )

		A_		:    int						     = 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-0_5,
		            """token""": 38015,
		            """token_str""": """ grouped""",
		        },
		        {
		            """sequence""": """The largest city in France is accuser""",
		            """score""": 2.1e-0_5,
		            """token""": 25506,
		            """token_str""": """ accuser""",
		        },
		    ]  ,  )

		A_		:    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-0_5, """token""": 13606, """token_str""": """ Clara"""},
		        {"""sequence""": """My name is Patrick""", """score""": 2e-0_5, """token""": 3499, """token_str""": """ Patrick"""},
		        {"""sequence""": """My name is Te""", """score""": 1.9e-0_5, """token""": 2941, """token_str""": """ Te"""},
		    ]  ,  )





	@require_torch
	def  lowerCamelCase(self				):
		A_		:    int						     = pipeline(task="""fill-mask"""  ,  model="""sshleifer/tiny-distilroberta-base"""  ,  top_k=2  ,  framework="""pt"""				)

		A_		:    Tuple						     = unmasker("""My name is <mask>"""				)
		self.assertEqual(
		    nested_simplify(lowerCAmelCase_  ,  decimals=6				)  ,  [
		        {"""sequence""": """My name is Maul""", """score""": 2.2e-0_5, """token""": 35676, """token_str""": """ Maul"""},
		        {"""sequence""": """My name isELS""", """score""": 2.2e-0_5, """token""": 16416, """token_str""": """ELS"""},
		    ]  ,  )

		A_		:    Union[str, Any]						     = 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-0_5,
		            """token""": 35676,
		            """token_str""": """ Maul""",
		        },
		        {"""sequence""": """The largest city in France isELS""", """score""": 2.2e-0_5, """token""": 16416, """token_str""": """ELS"""},
		    ]  ,  )

		A_		:    Optional[int]						     = 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-0_5, """token""": 3499, """token_str""": """ Patrick"""},
		        {"""sequence""": """My name is Te""", """score""": 2e-0_5, """token""": 2941, """token_str""": """ Te"""},
		        {"""sequence""": """My name is Clara""", """score""": 2e-0_5, """token""": 13606, """token_str""": """ Clara"""},
		    ]  ,  )

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

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





	@require_torch_gpu
	def  lowerCamelCase(self				):
		A_		:    str						     = pipeline("""fill-mask"""  ,  model="""hf-internal-testing/tiny-random-distilbert"""  ,  device=0  ,  framework="""pt"""				)

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

		A_		:    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  lowerCamelCase(self				):
		A_		:    List[str]						     = pipeline(task="""fill-mask"""  ,  model="""distilroberta-base"""  ,  top_k=2  ,  framework="""pt"""				)
		self.run_large_test(lowerCAmelCase_				)





	@slow
	@require_tf
	def  lowerCamelCase(self				):
		A_		:    Optional[Any]						     = pipeline(task="""fill-mask"""  ,  model="""distilroberta-base"""  ,  top_k=2  ,  framework="""tf"""				)
		self.run_large_test(lowerCAmelCase_				)





	def  lowerCamelCase(self  ,  lowerCAmelCase_				):
		A_		:    Optional[int]						     = unmasker("""My name is <mask>"""				)
		self.assertEqual(
		    nested_simplify(lowerCAmelCase_				)  ,  [
		        {"""sequence""": """My name is John""", """score""": 0.008, """token""": 610, """token_str""": """ John"""},
		        {"""sequence""": """My name is Chris""", """score""": 0.007, """token""": 1573, """token_str""": """ Chris"""},
		    ]  ,  )
		A_		:    Any						     = unmasker("""The largest city in France is <mask>"""				)
		self.assertEqual(
		    nested_simplify(lowerCAmelCase_				)  ,  [
		        {
		            """sequence""": """The largest city in France is Paris""",
		            """score""": 0.251,
		            """token""": 2201,
		            """token_str""": """ Paris""",
		        },
		        {
		            """sequence""": """The largest city in France is Lyon""",
		            """score""": 0.214,
		            """token""": 12790,
		            """token_str""": """ Lyon""",
		        },
		    ]  ,  )

		A_		:    Dict						     = unmasker("""My name is <mask>"""  ,  targets=[""" Patrick""", """ Clara""", """ Teven"""]  ,  top_k=3				)
		self.assertEqual(
		    nested_simplify(lowerCAmelCase_				)  ,  [
		        {"""sequence""": """My name is Patrick""", """score""": 0.005, """token""": 3499, """token_str""": """ Patrick"""},
		        {"""sequence""": """My name is Clara""", """score""": 0.000, """token""": 13606, """token_str""": """ Clara"""},
		        {"""sequence""": """My name is Te""", """score""": 0.000, """token""": 2941, """token_str""": """ Te"""},
		    ]  ,  )





	@require_torch
	def  lowerCamelCase(self				):
		A_		:    Any						     = pipeline(task="""fill-mask"""  ,  model="""sshleifer/tiny-distilroberta-base"""  ,  framework="""pt"""				)
		A_		:    Optional[int]						     = None
		A_		:    Any						     = None
		self.run_pipeline_test(lowerCAmelCase_  ,  []				)





	@require_tf
	def  lowerCamelCase(self				):
		A_		:    Optional[int]						     = pipeline(task="""fill-mask"""  ,  model="""sshleifer/tiny-distilroberta-base"""  ,  framework="""tf"""				)
		A_		:    Optional[int]						     = None
		A_		:    Union[str, Any]						     = None
		self.run_pipeline_test(lowerCAmelCase_  ,  []				)





	def  lowerCamelCase(self  ,  lowerCAmelCase_  ,  lowerCAmelCase_  ,  lowerCAmelCase_				):
		if tokenizer is None or tokenizer.mask_token_id is None:
			self.skipTest("""The provided tokenizer has no mask token, (probably reformer or wav2vec2)"""				)

		A_		:    Optional[Any]						     = FillMaskPipeline(model=lowerCAmelCase_  ,  tokenizer=lowerCAmelCase_				)
		A_		:    Optional[Any]						     = [
		    f"""This is another {tokenizer.mask_token} test""",
		]
		return fill_masker, examples





	def  lowerCamelCase(self  ,  lowerCAmelCase_  ,  lowerCAmelCase_				):
		A_		:    Any						     = fill_masker.tokenizer
		A_		:    Dict						     = fill_masker.model

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

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

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

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

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

		# Raises with invalid
		with self.assertRaises(lowerCAmelCase_				):
			A_		:    Dict						     = 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_				):
				A_		:    Tuple						     = fill_masker(f"""This is a {tokenizer.mask_token}"""  ,  targets=[""""""]				)
			with self.assertRaises(lowerCAmelCase_				):
				A_		:    Tuple						     = fill_masker(f"""This is a {tokenizer.mask_token}"""  ,  targets=""""""				)





	def  lowerCamelCase(self  ,  lowerCAmelCase_  ,  lowerCAmelCase_				):
		A_		:    Union[str, Any]						     = FillMaskPipeline(model=lowerCAmelCase_  ,  tokenizer=lowerCAmelCase_  ,  top_k=2				)
		A_		:    Optional[int]						     = 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_				)},
		    ]  ,  )

		A_		:    List[Any]						     = FillMaskPipeline(model=lowerCAmelCase_  ,  tokenizer=lowerCAmelCase_				)
		A_		:    List[str]						     = 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  lowerCamelCase(self  ,  lowerCAmelCase_  ,  lowerCAmelCase_				):
		A_		:    Tuple						     = tokenizer.get_vocab()
		A_		:    Any						     = FillMaskPipeline(model=lowerCAmelCase_  ,  tokenizer=lowerCAmelCase_				)

		# top_k=2, ntargets=3
		A_		:    str						     = sorted(vocab.keys()				)[:3]
		A_		:    Any						     = 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
		A_		:    List[str]						     = [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_				):
			A_		:    Optional[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  lowerCamelCase(self  ,  lowerCAmelCase_  ,  lowerCAmelCase_				):
		A_		:    List[Any]						     = FillMaskPipeline(model=lowerCAmelCase_  ,  tokenizer=lowerCAmelCase_				)
		A_		:    str						     = tokenizer.get_vocab()
		# String duplicates + id duplicates
		A_		:    str						     = sorted(vocab.keys()				)[:3]
		A_		:    Optional[int]						     = [targets[0], targets[1], targets[0], targets[2], targets[1]]
		A_		:    Union[str, Any]						     = 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  lowerCamelCase(self  ,  lowerCAmelCase_  ,  lowerCAmelCase_				):
		A_		:    Tuple						     = FillMaskPipeline(model=lowerCAmelCase_  ,  tokenizer=lowerCAmelCase_				)

		A_		:    Tuple						     = 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_				)},
		        ],
		    ]  ,  )









"""simple docstring"""
from __future__ import annotations






def       __UpperCamelCase						(		snake_case__ , snake_case__ = None , snake_case__ = None       ):
	if start is None:
		A_		:    Dict						     = 0

	if end is None:
		A_		:    Dict						     = len(snake_case__       ) - 1

	if start >= end:
		return

	A_		:    List[Any]						     = (start + end) // 2

	slowsort(snake_case__ , snake_case__ , snake_case__       )
	slowsort(snake_case__ , mid + 1 , snake_case__       )

	if sequence[end] < sequence[mid]:
		A_     ,  A_		:    Dict						     = sequence[mid], sequence[end]

	slowsort(snake_case__ , snake_case__ , end - 1       )


if __name__ == "__main__":
							from doctest import testmod

							testmod()

