


import unittest

import numpy as np

from transformers import is_flax_available
from transformers.testing_utils import require_flax

from ..test_modeling_flax_common import ids_tensor


if is_flax_available():
	import jax
	import jax.numpy as jnp

	from transformers.generation import (
	    FlaxForcedBOSTokenLogitsProcessor,
	    FlaxForcedEOSTokenLogitsProcessor,
	    FlaxLogitsProcessorList,
	    FlaxMinLengthLogitsProcessor,
	    FlaxTemperatureLogitsWarper,
	    FlaxTopKLogitsWarper,
	    FlaxTopPLogitsWarper,
	)






@require_flax
class      UpperCamelCase(	unittest.TestCase ):


					def 				SCREAMING_SNAKE_CASE_	(    self						:		Optional[int]  ,     SCREAMING_SNAKE_CASE						:		int  ,     SCREAMING_SNAKE_CASE						:		int    )      ->						Tuple:




											'''simple docstring'''

											__snake_case				=		jnp.ones((batch_size, length)    ) / length
											return scores


					def 				SCREAMING_SNAKE_CASE_	(    self						:		int    )      ->						List[str]:




											'''simple docstring'''

											__snake_case				=		None
											__snake_case				=		2_0

											__snake_case				=		self._get_uniform_logits(batch_size=2  ,     length=SCREAMING_SNAKE_CASE    )

											# tweak scores to not be uniform anymore
											__snake_case				=		scores.at[1, 5].set((1 / length) + 0.1    )  # peak, 1st batch
											__snake_case				=		scores.at[1, 1_0].set((1 / length) - 0.4    )  # valley, 1st batch

											# compute softmax
											__snake_case				=		jax.nn.softmax(SCREAMING_SNAKE_CASE  ,     axis=-1    )

											__snake_case				=		FlaxTemperatureLogitsWarper(temperature=0.5    )
											__snake_case				=		FlaxTemperatureLogitsWarper(temperature=1.3    )

											__snake_case				=		jax.nn.softmax(temp_dist_warper_sharper(SCREAMING_SNAKE_CASE  ,     scores.copy()  ,     cur_len=SCREAMING_SNAKE_CASE    )  ,     axis=-1    )
											__snake_case				=		jax.nn.softmax(temp_dist_warper_smoother(SCREAMING_SNAKE_CASE  ,     scores.copy()  ,     cur_len=SCREAMING_SNAKE_CASE    )  ,     axis=-1    )

											# uniform distribution stays uniform
											self.assertTrue(jnp.allclose(probs[0, :]  ,     warped_prob_sharp[0, :]  ,     atol=1e-3    )    )
											self.assertTrue(jnp.allclose(probs[0, :]  ,     warped_prob_smooth[0, :]  ,     atol=1e-3    )    )

											# sharp peaks get higher, valleys get lower
											self.assertLess(probs[1, :].max()  ,     warped_prob_sharp[1, :].max()    )
											self.assertGreater(probs[1, :].min()  ,     warped_prob_sharp[1, :].min()    )

											# smooth peaks get lower, valleys get higher
											self.assertGreater(probs[1, :].max()  ,     warped_prob_smooth[1, :].max()    )
											self.assertLess(probs[1, :].min()  ,     warped_prob_smooth[1, :].min()    )


					def 				SCREAMING_SNAKE_CASE_	(    self						:		int    )      ->						int:




											'''simple docstring'''

											__snake_case				=		None
											__snake_case				=		1_0
											__snake_case				=		2

											# create ramp distribution
											__snake_case				=		np.broadcast_to(np.arange(SCREAMING_SNAKE_CASE    )[None, :]  ,     (batch_size, vocab_size)    ).copy()
											__snake_case				=		ramp_logits[1:, : vocab_size // 2] + vocab_size

											__snake_case				=		FlaxTopKLogitsWarper(3    )

											__snake_case				=		top_k_warp(SCREAMING_SNAKE_CASE  ,     SCREAMING_SNAKE_CASE  ,     cur_len=SCREAMING_SNAKE_CASE    )

											# check that correct tokens are filtered
											self.assertListEqual(jnp.isinf(scores[0]    ).tolist()  ,     7 * [True] + 3 * [False]    )
											self.assertListEqual(jnp.isinf(scores[1]    ).tolist()  ,     2 * [True] + 3 * [False] + 5 * [True]    )

											# check special case
											__snake_case				=		5
											__snake_case				=		FlaxTopKLogitsWarper(top_k=1  ,     filter_value=0.0  ,     min_tokens_to_keep=3    )

											__snake_case				=		np.broadcast_to(np.arange(SCREAMING_SNAKE_CASE    )[None, :]  ,     (batch_size, length)    ).copy()
											__snake_case				=		top_k_warp_safety_check(SCREAMING_SNAKE_CASE  ,     SCREAMING_SNAKE_CASE  ,     cur_len=SCREAMING_SNAKE_CASE    )

											# min_tokens overwrites k: 3 tokens are kept => 2 tokens are nullified
											self.assertListEqual((scores == 0.0).sum(axis=-1    ).tolist()  ,     [2, 2]    )


					def 				SCREAMING_SNAKE_CASE_	(    self						:		Optional[int]    )      ->						Optional[Any]:




											'''simple docstring'''

											__snake_case				=		None
											__snake_case				=		1_0
											__snake_case				=		2

											# create distribution and take log (inverse to Softmax as taken in TopPLogitsWarper)
											__snake_case				=		np.log(np.array([[0.3, 0.1, 0.1, 0.5], [0.15, 0.3, 0.3, 0.25]]    )    )

											__snake_case				=		FlaxTopPLogitsWarper(0.8    )
											__snake_case				=		np.exp(top_p_warp(SCREAMING_SNAKE_CASE  ,     SCREAMING_SNAKE_CASE  ,     cur_len=SCREAMING_SNAKE_CASE    )    )

											# dist should be filtered to keep min num values so that sum is >= top_p
											# exp (-inf) => 0
											__snake_case				=		np.array([[0.3, 0.0, 0.0, 0.5], [0.0, 0.3, 0.3, 0.25]]    )
											self.assertTrue(np.allclose(SCREAMING_SNAKE_CASE  ,     SCREAMING_SNAKE_CASE  ,     atol=1e-3    )    )

											# check edge cases with negative and extreme logits
											__snake_case				=		np.broadcast_to(np.arange(SCREAMING_SNAKE_CASE    )[None, :]  ,     (batch_size, vocab_size)    ).copy() - (
											    vocab_size // 2
											)

											# make ramp_logits more extreme
											__snake_case				=		ramp_logits[1] * 100.0

											# make sure at least 2 tokens are kept
											__snake_case				=		FlaxTopPLogitsWarper(0.9  ,     min_tokens_to_keep=2  ,     filter_value=0.0    )
											__snake_case				=		top_p_warp(SCREAMING_SNAKE_CASE  ,     SCREAMING_SNAKE_CASE  ,     cur_len=SCREAMING_SNAKE_CASE    )

											# first batch should keep three tokens, second batch would keep only 1, but due to `min_tokens_to_keep=2` keeps 2.
											self.assertListEqual((filtered_dist != 0.0).sum(axis=-1    ).tolist()  ,     [3, 2]    )


					def 				SCREAMING_SNAKE_CASE_	(    self						:		List[str]    )      ->						int:




											'''simple docstring'''

											__snake_case				=		2_0
											__snake_case				=		4
											__snake_case				=		0

											__snake_case				=		FlaxMinLengthLogitsProcessor(min_length=1_0  ,     eos_token_id=SCREAMING_SNAKE_CASE    )

											# check that min length is applied at length 5
											__snake_case				=		ids_tensor((batch_size, 2_0)  ,     vocab_size=2_0    )
											__snake_case				=		5
											__snake_case				=		self._get_uniform_logits(SCREAMING_SNAKE_CASE  ,     SCREAMING_SNAKE_CASE    )
											__snake_case				=		min_dist_processor(SCREAMING_SNAKE_CASE  ,     SCREAMING_SNAKE_CASE  ,     cur_len=SCREAMING_SNAKE_CASE    )
											self.assertListEqual(scores_before_min_length[:, eos_token_id].tolist()  ,     4 * [-float("inf"    )]    )

											# check that min length is not applied anymore at length 15
											__snake_case				=		self._get_uniform_logits(SCREAMING_SNAKE_CASE  ,     SCREAMING_SNAKE_CASE    )
											__snake_case				=		1_5
											__snake_case				=		min_dist_processor(SCREAMING_SNAKE_CASE  ,     SCREAMING_SNAKE_CASE  ,     cur_len=SCREAMING_SNAKE_CASE    )
											self.assertFalse(jnp.isinf(SCREAMING_SNAKE_CASE    ).any()    )


					def 				SCREAMING_SNAKE_CASE_	(    self						:		str    )      ->						str:




											'''simple docstring'''

											__snake_case				=		2_0
											__snake_case				=		4
											__snake_case				=		0

											__snake_case				=		FlaxForcedBOSTokenLogitsProcessor(bos_token_id=SCREAMING_SNAKE_CASE    )

											# check that all scores are -inf except the bos_token_id score
											__snake_case				=		ids_tensor((batch_size, 1)  ,     vocab_size=2_0    )
											__snake_case				=		1
											__snake_case				=		self._get_uniform_logits(SCREAMING_SNAKE_CASE  ,     SCREAMING_SNAKE_CASE    )
											__snake_case				=		logits_processor(SCREAMING_SNAKE_CASE  ,     SCREAMING_SNAKE_CASE  ,     cur_len=SCREAMING_SNAKE_CASE    )
											self.assertTrue(jnp.isneginf(scores[:, bos_token_id + 1 :]    ).all()    )
											self.assertListEqual(scores[:, bos_token_id].tolist()  ,     4 * [0]    )  # score for bos_token_id shold be zero

											# check that bos_token_id is not forced if current length is greater than 1
											__snake_case				=		3
											__snake_case				=		self._get_uniform_logits(SCREAMING_SNAKE_CASE  ,     SCREAMING_SNAKE_CASE    )
											__snake_case				=		logits_processor(SCREAMING_SNAKE_CASE  ,     SCREAMING_SNAKE_CASE  ,     cur_len=SCREAMING_SNAKE_CASE    )
											self.assertFalse(jnp.isinf(SCREAMING_SNAKE_CASE    ).any()    )


					def 				SCREAMING_SNAKE_CASE_	(    self						:		Dict    )      ->						Optional[int]:




											'''simple docstring'''

											__snake_case				=		2_0
											__snake_case				=		4
											__snake_case				=		0
											__snake_case				=		5

											__snake_case				=		FlaxForcedEOSTokenLogitsProcessor(max_length=SCREAMING_SNAKE_CASE  ,     eos_token_id=SCREAMING_SNAKE_CASE    )

											# check that all scores are -inf except the eos_token_id when max_length is reached
											__snake_case				=		ids_tensor((batch_size, 4)  ,     vocab_size=2_0    )
											__snake_case				=		4
											__snake_case				=		self._get_uniform_logits(SCREAMING_SNAKE_CASE  ,     SCREAMING_SNAKE_CASE    )
											__snake_case				=		logits_processor(SCREAMING_SNAKE_CASE  ,     SCREAMING_SNAKE_CASE  ,     cur_len=SCREAMING_SNAKE_CASE    )
											self.assertTrue(jnp.isneginf(scores[:, eos_token_id + 1 :]    ).all()    )
											self.assertListEqual(scores[:, eos_token_id].tolist()  ,     4 * [0]    )  # score for eos_token_id should be zero

											# check that eos_token_id is not forced if max_length is not reached
											__snake_case				=		3
											__snake_case				=		self._get_uniform_logits(SCREAMING_SNAKE_CASE  ,     SCREAMING_SNAKE_CASE    )
											__snake_case				=		logits_processor(SCREAMING_SNAKE_CASE  ,     SCREAMING_SNAKE_CASE  ,     cur_len=SCREAMING_SNAKE_CASE    )
											self.assertFalse(jnp.isinf(SCREAMING_SNAKE_CASE    ).any()    )


					def 				SCREAMING_SNAKE_CASE_	(    self						:		List[str]    )      ->						List[str]:




											'''simple docstring'''

											__snake_case				=		4
											__snake_case				=		1_0
											__snake_case				=		1_5
											__snake_case				=		2
											__snake_case				=		1
											__snake_case				=		1_5

											# dummy input_ids and scores
											__snake_case				=		ids_tensor((batch_size, sequence_length)  ,     SCREAMING_SNAKE_CASE    )
											__snake_case				=		input_ids.copy()

											__snake_case				=		self._get_uniform_logits(SCREAMING_SNAKE_CASE  ,     SCREAMING_SNAKE_CASE    )
											__snake_case				=		scores.copy()

											# instantiate all dist processors
											__snake_case				=		FlaxTemperatureLogitsWarper(temperature=0.5    )
											__snake_case				=		FlaxTopKLogitsWarper(3    )
											__snake_case				=		FlaxTopPLogitsWarper(0.8    )

											# instantiate all logits processors
											__snake_case				=		FlaxMinLengthLogitsProcessor(min_length=1_0  ,     eos_token_id=SCREAMING_SNAKE_CASE    )
											__snake_case				=		FlaxForcedBOSTokenLogitsProcessor(bos_token_id=SCREAMING_SNAKE_CASE    )
											__snake_case				=		FlaxForcedEOSTokenLogitsProcessor(max_length=SCREAMING_SNAKE_CASE  ,     eos_token_id=SCREAMING_SNAKE_CASE    )

											__snake_case				=		1_0

											# no processor list
											__snake_case				=		temp_dist_warp(SCREAMING_SNAKE_CASE  ,     SCREAMING_SNAKE_CASE  ,     cur_len=SCREAMING_SNAKE_CASE    )
											__snake_case				=		top_k_warp(SCREAMING_SNAKE_CASE  ,     SCREAMING_SNAKE_CASE  ,     cur_len=SCREAMING_SNAKE_CASE    )
											__snake_case				=		top_p_warp(SCREAMING_SNAKE_CASE  ,     SCREAMING_SNAKE_CASE  ,     cur_len=SCREAMING_SNAKE_CASE    )
											__snake_case				=		min_dist_proc(SCREAMING_SNAKE_CASE  ,     SCREAMING_SNAKE_CASE  ,     cur_len=SCREAMING_SNAKE_CASE    )
											__snake_case				=		bos_dist_proc(SCREAMING_SNAKE_CASE  ,     SCREAMING_SNAKE_CASE  ,     cur_len=SCREAMING_SNAKE_CASE    )
											__snake_case				=		eos_dist_proc(SCREAMING_SNAKE_CASE  ,     SCREAMING_SNAKE_CASE  ,     cur_len=SCREAMING_SNAKE_CASE    )

											# with processor list
											__snake_case				=		FlaxLogitsProcessorList(
											    [temp_dist_warp, top_k_warp, top_p_warp, min_dist_proc, bos_dist_proc, eos_dist_proc]    )
											__snake_case				=		processor(SCREAMING_SNAKE_CASE  ,     SCREAMING_SNAKE_CASE  ,     cur_len=SCREAMING_SNAKE_CASE    )

											# scores should be equal
											self.assertTrue(jnp.allclose(SCREAMING_SNAKE_CASE  ,     SCREAMING_SNAKE_CASE  ,     atol=1e-3    )    )

											# input_ids should never be changed
											self.assertListEqual(input_ids.tolist()  ,     input_ids_comp.tolist()    )






					def 				SCREAMING_SNAKE_CASE_	(    self						:		str    )      ->						Tuple:




											'''simple docstring'''

											__snake_case				=		4
											__snake_case				=		1_0
											__snake_case				=		1_5
											__snake_case				=		2
											__snake_case				=		1
											__snake_case				=		1_5

											# dummy input_ids and scores
											__snake_case				=		ids_tensor((batch_size, sequence_length)  ,     SCREAMING_SNAKE_CASE    )
											__snake_case				=		input_ids.copy()

											__snake_case				=		self._get_uniform_logits(SCREAMING_SNAKE_CASE  ,     SCREAMING_SNAKE_CASE    )
											__snake_case				=		scores.copy()

											# instantiate all dist processors
											__snake_case				=		FlaxTemperatureLogitsWarper(temperature=0.5    )
											__snake_case				=		FlaxTopKLogitsWarper(3    )
											__snake_case				=		FlaxTopPLogitsWarper(0.8    )

											# instantiate all logits processors
											__snake_case				=		FlaxMinLengthLogitsProcessor(min_length=1_0  ,     eos_token_id=SCREAMING_SNAKE_CASE    )
											__snake_case				=		FlaxForcedBOSTokenLogitsProcessor(bos_token_id=SCREAMING_SNAKE_CASE    )
											__snake_case				=		FlaxForcedEOSTokenLogitsProcessor(max_length=SCREAMING_SNAKE_CASE  ,     eos_token_id=SCREAMING_SNAKE_CASE    )

											__snake_case				=		1_0

											# no processor list
											def run_no_processor_list(SCREAMING_SNAKE_CASE						:		List[str]  ,     SCREAMING_SNAKE_CASE						:		List[Any]  ,     SCREAMING_SNAKE_CASE						:		int    ):
																	__snake_case				=		temp_dist_warp(SCREAMING_SNAKE_CASE  ,     SCREAMING_SNAKE_CASE  ,     cur_len=SCREAMING_SNAKE_CASE    )
																	__snake_case				=		top_k_warp(SCREAMING_SNAKE_CASE  ,     SCREAMING_SNAKE_CASE  ,     cur_len=SCREAMING_SNAKE_CASE    )
																	__snake_case				=		top_p_warp(SCREAMING_SNAKE_CASE  ,     SCREAMING_SNAKE_CASE  ,     cur_len=SCREAMING_SNAKE_CASE    )
																	__snake_case				=		min_dist_proc(SCREAMING_SNAKE_CASE  ,     SCREAMING_SNAKE_CASE  ,     cur_len=SCREAMING_SNAKE_CASE    )
																	__snake_case				=		bos_dist_proc(SCREAMING_SNAKE_CASE  ,     SCREAMING_SNAKE_CASE  ,     cur_len=SCREAMING_SNAKE_CASE    )
																	__snake_case				=		eos_dist_proc(SCREAMING_SNAKE_CASE  ,     SCREAMING_SNAKE_CASE  ,     cur_len=SCREAMING_SNAKE_CASE    )
																	return scores

											# with processor list
											def run_processor_list(SCREAMING_SNAKE_CASE						:		Dict  ,     SCREAMING_SNAKE_CASE						:		Union[str, Any]  ,     SCREAMING_SNAKE_CASE						:		Optional[int]    ):
																	__snake_case				=		FlaxLogitsProcessorList(
																	    [temp_dist_warp, top_k_warp, top_p_warp, min_dist_proc, bos_dist_proc, eos_dist_proc]    )
																	__snake_case				=		processor(SCREAMING_SNAKE_CASE  ,     SCREAMING_SNAKE_CASE  ,     cur_len=SCREAMING_SNAKE_CASE    )
																	return scores

											__snake_case				=		jax.jit(SCREAMING_SNAKE_CASE    )
											__snake_case				=		jax.jit(SCREAMING_SNAKE_CASE    )

											__snake_case				=		jitted_run_no_processor_list(SCREAMING_SNAKE_CASE  ,     SCREAMING_SNAKE_CASE  ,     SCREAMING_SNAKE_CASE    )
											__snake_case				=		jitted_run_processor_list(SCREAMING_SNAKE_CASE  ,     SCREAMING_SNAKE_CASE  ,     SCREAMING_SNAKE_CASE    )

											# scores should be equal
											self.assertTrue(jnp.allclose(SCREAMING_SNAKE_CASE  ,     SCREAMING_SNAKE_CASE  ,     atol=1e-3    )    )

											# input_ids should never be changed
											self.assertListEqual(input_ids.tolist()  ,     input_ids_comp.tolist()    )









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 ):
					snake_case_		:					int    					=						MODEL_FOR_MASKED_LM_MAPPING
					snake_case_		:					Optional[int]    					=						TF_MODEL_FOR_MASKED_LM_MAPPING


					def 				SCREAMING_SNAKE_CASE_	(    self						:		Dict    )      ->						Union[str, Any]:




											'''simple docstring'''

											super().tearDown()
											# clean-up as much as possible GPU memory occupied by PyTorch
											gc.collect()
											if is_torch_available():
																	import torch

																	torch.cuda.empty_cache()


					@require_tf
					def 				SCREAMING_SNAKE_CASE_	(    self						:		List[Any]    )      ->						Union[str, Any]:




											'''simple docstring'''

											__snake_case				=		pipeline(task="fill-mask"  ,     model="sshleifer/tiny-distilroberta-base"  ,     top_k=2  ,     framework="tf"    )
											__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_8_0_1_5, "token_str": " grouped"},
											        {"sequence": "My name is accuser", "score": 2.1e-0_5, "token": 2_5_5_0_6, "token_str": " accuser"},
											    ]  ,     )

											__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_8_0_1_5,
											            "token_str": " grouped",
											        },
											        {
											            "sequence": "The largest city in France is accuser",
											            "score": 2.1e-0_5,
											            "token": 2_5_5_0_6,
											            "token_str": " accuser",
											        },
											    ]  ,     )

											__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_3_6_0_6, "token_str": " Clara"},
											        {"sequence": "My name is Patrick", "score": 2e-0_5, "token": 3_4_9_9, "token_str": " Patrick"},
											        {"sequence": "My name is Te", "score": 1.9e-0_5, "token": 2_9_4_1, "token_str": " Te"},
											    ]  ,     )


					@require_torch
					def 				SCREAMING_SNAKE_CASE_	(    self						:		List[str]    )      ->						List[str]:




											'''simple docstring'''

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

											__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_5_6_7_6, "token_str": " Maul"},
											        {"sequence": "My name isELS", "score": 2.2e-0_5, "token": 1_6_4_1_6, "token_str": "ELS"},
											    ]  ,     )

											__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_5_6_7_6,
											            "token_str": " Maul",
											        },
											        {"sequence": "The largest city in France isELS", "score": 2.2e-0_5, "token": 1_6_4_1_6, "token_str": "ELS"},
											    ]  ,     )

											__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": 3_4_9_9, "token_str": " Patrick"},
											        {"sequence": "My name is Te", "score": 2e-0_5, "token": 2_9_4_1, "token_str": " Te"},
											        {"sequence": "My name is Clara", "score": 2e-0_5, "token": 1_3_6_0_6, "token_str": " Clara"},
											    ]  ,     )

											__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_5_6_7_6,
											                "token_str": " Maul",
											                "sequence": "<s>My name is Maul<mask></s>",
											            },
											            {"score": 2.2e-0_5, "token": 1_6_4_1_6, "token_str": "ELS", "sequence": "<s>My name isELS<mask></s>"},
											        ],
											        [
											            {
											                "score": 2.2e-0_5,
											                "token": 3_5_6_7_6,
											                "token_str": " Maul",
											                "sequence": "<s>My name is<mask> Maul</s>",
											            },
											            {"score": 2.2e-0_5, "token": 1_6_4_1_6, "token_str": "ELS", "sequence": "<s>My name is<mask>ELS</s>"},
											        ],
											    ]  ,     )


					@require_torch_gpu
					def 				SCREAMING_SNAKE_CASE_	(    self						:		Optional[Any]    )      ->						Union[str, Any]:




											'''simple docstring'''

											__snake_case				=		pipeline("fill-mask"  ,     model="hf-internal-testing/tiny-random-distilbert"  ,     device=0  ,     framework="pt"    )

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

											__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 				SCREAMING_SNAKE_CASE_	(    self						:		List[str]    )      ->						Tuple:




											'''simple docstring'''

											__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 				SCREAMING_SNAKE_CASE_	(    self						:		Optional[Any]    )      ->						int:




											'''simple docstring'''

											__snake_case				=		pipeline(task="fill-mask"  ,     model="distilroberta-base"  ,     top_k=2  ,     framework="tf"    )
											self.run_large_test(SCREAMING_SNAKE_CASE    )


					def 				SCREAMING_SNAKE_CASE_	(    self						:		Any  ,     SCREAMING_SNAKE_CASE						:		Optional[Any]    )      ->						str:




											'''simple docstring'''

											__snake_case				=		unmasker("My name is <mask>"    )
											self.assertEqual(
											    nested_simplify(SCREAMING_SNAKE_CASE    )  ,     [
											        {"sequence": "My name is John", "score": 0.008, "token": 6_1_0, "token_str": " John"},
											        {"sequence": "My name is Chris", "score": 0.007, "token": 1_5_7_3, "token_str": " Chris"},
											    ]  ,     )
											__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.251,
											            "token": 2_2_0_1,
											            "token_str": " Paris",
											        },
											        {
											            "sequence": "The largest city in France is Lyon",
											            "score": 0.214,
											            "token": 1_2_7_9_0,
											            "token_str": " Lyon",
											        },
											    ]  ,     )

											__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.005, "token": 3_4_9_9, "token_str": " Patrick"},
											        {"sequence": "My name is Clara", "score": 0.000, "token": 1_3_6_0_6, "token_str": " Clara"},
											        {"sequence": "My name is Te", "score": 0.000, "token": 2_9_4_1, "token_str": " Te"},
											    ]  ,     )


					@require_torch
					def 				SCREAMING_SNAKE_CASE_	(    self						:		Dict    )      ->						str:




											'''simple docstring'''

											__snake_case				=		pipeline(task="fill-mask"  ,     model="sshleifer/tiny-distilroberta-base"  ,     framework="pt"    )
											__snake_case				=		None
											__snake_case				=		None
											self.run_pipeline_test(SCREAMING_SNAKE_CASE  ,     []    )


					@require_tf
					def 				SCREAMING_SNAKE_CASE_	(    self						:		List[Any]    )      ->						Optional[int]:




											'''simple docstring'''

											__snake_case				=		pipeline(task="fill-mask"  ,     model="sshleifer/tiny-distilroberta-base"  ,     framework="tf"    )
											__snake_case				=		None
											__snake_case				=		None
											self.run_pipeline_test(SCREAMING_SNAKE_CASE  ,     []    )


					def 				SCREAMING_SNAKE_CASE_	(    self						:		Tuple  ,     SCREAMING_SNAKE_CASE						:		Any  ,     SCREAMING_SNAKE_CASE						:		Optional[Any]  ,     SCREAMING_SNAKE_CASE						:		Tuple    )      ->						int:




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

											__snake_case				=		FillMaskPipeline(model=SCREAMING_SNAKE_CASE  ,     tokenizer=SCREAMING_SNAKE_CASE    )
											__snake_case				=		[
											    f'''This is another {tokenizer.mask_token} test''',
											]
											return fill_masker, examples


					def 				SCREAMING_SNAKE_CASE_	(    self						:		Any  ,     SCREAMING_SNAKE_CASE						:		int  ,     SCREAMING_SNAKE_CASE						:		int    )      ->						Optional[Any]:




											'''simple docstring'''

											__snake_case				=		fill_masker.tokenizer
											__snake_case				=		fill_masker.model

											__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    )},
											    ]  ,     )

											__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    )},
											    ]  ,     )

											__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 				SCREAMING_SNAKE_CASE_	(    self						:		Union[str, Any]  ,     SCREAMING_SNAKE_CASE						:		Dict  ,     SCREAMING_SNAKE_CASE						:		Union[str, Any]    )      ->						Any:




											'''simple docstring'''

											__snake_case				=		tokenizer.get_vocab()
											__snake_case				=		sorted(vocab.keys()    )[:2]
											# Pipeline argument
											__snake_case				=		FillMaskPipeline(model=SCREAMING_SNAKE_CASE  ,     tokenizer=SCREAMING_SNAKE_CASE  ,     targets=SCREAMING_SNAKE_CASE    )
											__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    )},
											    ]  ,     )
											__snake_case				=		{vocab[el] for el in targets}
											self.assertEqual({el["token"] for el in outputs}  ,     SCREAMING_SNAKE_CASE    )
											__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
											__snake_case				=		FillMaskPipeline(model=SCREAMING_SNAKE_CASE  ,     tokenizer=SCREAMING_SNAKE_CASE    )
											__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    )},
											    ]  ,     )
											__snake_case				=		{vocab[el] for el in targets}
											self.assertEqual({el["token"] for el in outputs}  ,     SCREAMING_SNAKE_CASE    )
											__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
											__snake_case				=		fill_masker(f'''This is a {tokenizer.mask_token}'''  ,     targets=SCREAMING_SNAKE_CASE    )
											__snake_case				=		[top_mask["token_str"] for top_mask in outputs]
											__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    ):
																	__snake_case				=		fill_masker(f'''This is a {tokenizer.mask_token}'''  ,     targets=SCREAMING_SNAKE_CASE    )
																	__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    ):
																	__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    ):
																							__snake_case				=		fill_masker(f'''This is a {tokenizer.mask_token}'''  ,     targets=[""]    )
																	with self.assertRaises(SCREAMING_SNAKE_CASE    ):
																							__snake_case				=		fill_masker(f'''This is a {tokenizer.mask_token}'''  ,     targets=""    )


					def 				SCREAMING_SNAKE_CASE_	(    self						:		Optional[int]  ,     SCREAMING_SNAKE_CASE						:		Union[str, Any]  ,     SCREAMING_SNAKE_CASE						:		List[str]    )      ->						Optional[Any]:




											'''simple docstring'''

											__snake_case				=		FillMaskPipeline(model=SCREAMING_SNAKE_CASE  ,     tokenizer=SCREAMING_SNAKE_CASE  ,     top_k=2    )
											__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    )},
											    ]  ,     )

											__snake_case				=		FillMaskPipeline(model=SCREAMING_SNAKE_CASE  ,     tokenizer=SCREAMING_SNAKE_CASE    )
											__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 				SCREAMING_SNAKE_CASE_	(    self						:		List[Any]  ,     SCREAMING_SNAKE_CASE						:		str  ,     SCREAMING_SNAKE_CASE						:		List[Any]    )      ->						Dict:




											'''simple docstring'''

											__snake_case				=		tokenizer.get_vocab()
											__snake_case				=		FillMaskPipeline(model=SCREAMING_SNAKE_CASE  ,     tokenizer=SCREAMING_SNAKE_CASE    )

											# top_k=2, ntargets=3
											__snake_case				=		sorted(vocab.keys()    )[:3]
											__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
											__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    ):
																	__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 				SCREAMING_SNAKE_CASE_	(    self						:		Optional[int]  ,     SCREAMING_SNAKE_CASE						:		Dict  ,     SCREAMING_SNAKE_CASE						:		Dict    )      ->						Optional[Any]:




											'''simple docstring'''

											__snake_case				=		FillMaskPipeline(model=SCREAMING_SNAKE_CASE  ,     tokenizer=SCREAMING_SNAKE_CASE    )
											__snake_case				=		tokenizer.get_vocab()
											# String duplicates + id duplicates
											__snake_case				=		sorted(vocab.keys()    )[:3]
											__snake_case				=		[targets[0], targets[1], targets[0], targets[2], targets[1]]
											__snake_case				=		fill_masker(f'''My name is {tokenizer.mask_token}'''  ,     targets=SCREAMING_SNAKE_CASE  ,     top_k=1_0    )

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






					def 				SCREAMING_SNAKE_CASE_	(    self						:		str  ,     SCREAMING_SNAKE_CASE						:		Optional[Any]  ,     SCREAMING_SNAKE_CASE						:		str    )      ->						Optional[Any]:




											'''simple docstring'''

											__snake_case				=		FillMaskPipeline(model=SCREAMING_SNAKE_CASE  ,     tokenizer=SCREAMING_SNAKE_CASE    )

											__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    )},
											        ],
											    ]  ,     )





