






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





				"""simple docstring"""







				UpperCamelCase__ :      List[str]			 =MODEL_FOR_MASKED_LM_MAPPING
				UpperCamelCase__ :      Tuple			 =TF_MODEL_FOR_MASKED_LM_MAPPING


				def       __lowercase							( self    ):




									"""simple docstring"""

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

														torch.cuda.empty_cache()


				@require_tf
				def       __lowercase							( self    ):




									"""simple docstring"""

									__UpperCamelCase      :					Optional[int]       		=pipeline(task='fill-mask'							,  model='sshleifer/tiny-distilroberta-base'							,  top_k=2							,  framework='tf'    )
									__UpperCamelCase      :					List[Any]       		=unmasker('My name is <mask>'    )
									self.assertEqual(
									    nested_simplify(lowerCamelCase__							,  decimals=6    )							,  [
									        {'sequence': 'My name is grouped', 'score': 2.1E-05, 'token': 38015, 'token_str': ' grouped'},
									        {'sequence': 'My name is accuser', 'score': 2.1E-05, 'token': 25506, 'token_str': ' accuser'},
									    ]							,  )

									__UpperCamelCase      :					Any       		=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-05,
									            'token': 38015,
									            'token_str': ' grouped',
									        },
									        {
									            'sequence': 'The largest city in France is accuser',
									            'score': 2.1E-05,
									            'token': 25506,
									            'token_str': ' accuser',
									        },
									    ]							,  )

									__UpperCamelCase      :					List[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-05, 'token': 13606, 'token_str': ' Clara'},
									        {'sequence': 'My name is Patrick', 'score': 2E-05, 'token': 3499, 'token_str': ' Patrick'},
									        {'sequence': 'My name is Te', 'score': 1.9E-05, 'token': 2941, 'token_str': ' Te'},
									    ]							,  )


				@require_torch
				def       __lowercase							( self    ):




									"""simple docstring"""

									__UpperCamelCase      :					Optional[Any]       		=pipeline(task='fill-mask'							,  model='sshleifer/tiny-distilroberta-base'							,  top_k=2							,  framework='pt'    )

									__UpperCamelCase      :					Optional[int]       		=unmasker('My name is <mask>'    )
									self.assertEqual(
									    nested_simplify(lowerCamelCase__							,  decimals=6    )							,  [
									        {'sequence': 'My name is Maul', 'score': 2.2E-05, 'token': 35676, 'token_str': ' Maul'},
									        {'sequence': 'My name isELS', 'score': 2.2E-05, 'token': 16416, 'token_str': 'ELS'},
									    ]							,  )

									__UpperCamelCase      :					Optional[int]       		=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-05,
									            'token': 35676,
									            'token_str': ' Maul',
									        },
									        {'sequence': 'The largest city in France isELS', 'score': 2.2E-05, 'token': 16416, 'token_str': 'ELS'},
									    ]							,  )

									__UpperCamelCase      :					Union[str, Any]       		=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-05, 'token': 3499, 'token_str': ' Patrick'},
									        {'sequence': 'My name is Te', 'score': 2E-05, 'token': 2941, 'token_str': ' Te'},
									        {'sequence': 'My name is Clara', 'score': 2E-05, 'token': 13606, 'token_str': ' Clara'},
									    ]							,  )

									__UpperCamelCase      :					int       		=unmasker('My name is <mask> <mask>'							,  top_k=2    )

									self.assertEqual(
									    nested_simplify(lowerCamelCase__							,  decimals=6    )							,  [
									        [
									            {
									                'score': 2.2E-05,
									                'token': 35676,
									                'token_str': ' Maul',
									                'sequence': '<s>My name is Maul<mask></s>',
									            },
									            {'score': 2.2E-05, 'token': 16416, 'token_str': 'ELS', 'sequence': '<s>My name isELS<mask></s>'},
									        ],
									        [
									            {
									                'score': 2.2E-05,
									                'token': 35676,
									                'token_str': ' Maul',
									                'sequence': '<s>My name is<mask> Maul</s>',
									            },
									            {'score': 2.2E-05, 'token': 16416, 'token_str': 'ELS', 'sequence': '<s>My name is<mask>ELS</s>'},
									        ],
									    ]							,  )


				@require_torch_gpu
				def       __lowercase							( self    ):




									"""simple docstring"""

									__UpperCamelCase      :					Any       		=pipeline('fill-mask'							,  model='hf-internal-testing/tiny-random-distilbert'							,  device=0							,  framework='pt'    )

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

									__UpperCamelCase      :					List[Any]       		=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       __lowercase							( self    ):




									"""simple docstring"""

									__UpperCamelCase      :					str       		=pipeline(task='fill-mask'							,  model='distilroberta-base'							,  top_k=2							,  framework='pt'    )
									self.run_large_test(lowerCamelCase__    )


				@slow
				@require_tf
				def       __lowercase							( self    ):




									"""simple docstring"""

									__UpperCamelCase      :					str       		=pipeline(task='fill-mask'							,  model='distilroberta-base'							,  top_k=2							,  framework='tf'    )
									self.run_large_test(lowerCamelCase__    )


				def       __lowercase							( self							,  lowerCamelCase__    ):




									"""simple docstring"""

									__UpperCamelCase      :					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'},
									    ]							,  )
									__UpperCamelCase      :					Optional[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',
									        },
									    ]							,  )

									__UpperCamelCase      :					int       		=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       __lowercase							( self    ):




									"""simple docstring"""

									__UpperCamelCase      :					List[str]       		=pipeline(task='fill-mask'							,  model='sshleifer/tiny-distilroberta-base'							,  framework='pt'    )
									__UpperCamelCase      :					List[str]       		=None
									__UpperCamelCase      :					Union[str, Any]       		=None
									self.run_pipeline_test(lowerCamelCase__							,  []    )


				@require_tf
				def       __lowercase							( self    ):




									"""simple docstring"""

									__UpperCamelCase      :					str       		=pipeline(task='fill-mask'							,  model='sshleifer/tiny-distilroberta-base'							,  framework='tf'    )
									__UpperCamelCase      :					str       		=None
									__UpperCamelCase      :					Tuple       		=None
									self.run_pipeline_test(lowerCamelCase__							,  []    )


				def       __lowercase							( self							,  lowerCamelCase__							,  lowerCamelCase__							,  lowerCamelCase__    ):




									"""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      :					Tuple       		=FillMaskPipeline(model=lowerCamelCase__							,  tokenizer=lowerCamelCase__    )
									__UpperCamelCase      :					List[str]       		=[
									    f'This is another {tokenizer.mask_token} test',
									]
									return fill_masker, examples


				def       __lowercase							( self							,  lowerCamelCase__							,  lowerCamelCase__    ):




									"""simple docstring"""

									__UpperCamelCase      :					str       		=fill_masker.tokenizer
									__UpperCamelCase      :					Optional[Any]       		=fill_masker.model

									__UpperCamelCase      :					Tuple       		=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__    )},
									    ]							,  )

									__UpperCamelCase      :					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__    )},
									        {'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__    )},
									    ]							,  )

									__UpperCamelCase      :					List[Any]       		=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       __lowercase							( self							,  lowerCamelCase__							,  lowerCamelCase__    ):




									"""simple docstring"""

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

									# Call argument
									__UpperCamelCase      :					Union[str, Any]       		=FillMaskPipeline(model=lowerCamelCase__							,  tokenizer=lowerCamelCase__    )
									__UpperCamelCase      :					Union[str, Any]       		=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__    )},
									    ]							,  )
									__UpperCamelCase      :					List[Any]       		={vocab[el] for el in targets}
									self.assertEqual({el['token'] for el in outputs}							,  lowerCamelCase__    )
									__UpperCamelCase      :					Tuple       		=[tokenizer.decode([x]    ) for x in target_ids]
									self.assertEqual({el['token_str'] for el in outputs}							,  set(lowerCamelCase__    )    )

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

									# Raises with invalid
									with self.assertRaises(lowerCamelCase__    ):
														__UpperCamelCase      :					Tuple       		=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__    ):
																			__UpperCamelCase      :					Any       		=fill_masker(f'This is a {tokenizer.mask_token}'							,  targets=['']    )
														with self.assertRaises(lowerCamelCase__    ):
																			__UpperCamelCase      :					Dict       		=fill_masker(f'This is a {tokenizer.mask_token}'							,  targets=''    )


				def       __lowercase							( self							,  lowerCamelCase__							,  lowerCamelCase__    ):




									"""simple docstring"""

									__UpperCamelCase      :					Any       		=FillMaskPipeline(model=lowerCamelCase__							,  tokenizer=lowerCamelCase__							,  top_k=2    )
									__UpperCamelCase      :					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__    )},
									    ]							,  )

									__UpperCamelCase      :					Optional[int]       		=FillMaskPipeline(model=lowerCamelCase__							,  tokenizer=lowerCamelCase__    )
									__UpperCamelCase      :					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       __lowercase							( self							,  lowerCamelCase__							,  lowerCamelCase__    ):




									"""simple docstring"""

									__UpperCamelCase      :					Dict       		=tokenizer.get_vocab()
									__UpperCamelCase      :					Dict       		=FillMaskPipeline(model=lowerCamelCase__							,  tokenizer=lowerCamelCase__    )

									# top_k=2, ntargets=3
									__UpperCamelCase      :					Any       		=sorted(vocab.keys()    )[:3]
									__UpperCamelCase      :					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
									__UpperCamelCase      :					Any       		=[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__    ):
														__UpperCamelCase      :					List[Any]       		=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       __lowercase							( self							,  lowerCamelCase__							,  lowerCamelCase__    ):




									"""simple docstring"""

									__UpperCamelCase      :					int       		=FillMaskPipeline(model=lowerCamelCase__							,  tokenizer=lowerCamelCase__    )
									__UpperCamelCase      :					Optional[Any]       		=tokenizer.get_vocab()
									# String duplicates + id duplicates
									__UpperCamelCase      :					Tuple       		=sorted(vocab.keys()    )[:3]
									__UpperCamelCase      :					int       		=[targets[0], targets[1], targets[0], targets[2], targets[1]]
									__UpperCamelCase      :					Dict       		=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       __lowercase							( self							,  lowerCamelCase__							,  lowerCamelCase__    ):




									"""simple docstring"""

									__UpperCamelCase      :					int       		=FillMaskPipeline(model=lowerCamelCase__							,  tokenizer=lowerCamelCase__    )

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



# Lint as: python3
# pylint: enable=line-too-long
# pylint: disable=g-import-not-at-top,g-bad-import-order,wrong-import-position

__A				='''2.13.1'''

import platform

import pyarrow
from packaging import version


if version.parse(platform.python_version()) < version.parse('''3.7'''):
			raise ImportWarning(
			    '''To use `datasets`, Python>=3.7 is required, and the current version of Python doesn\'t match this condition.'''
			)

if version.parse(pyarrow.__version__).major < 8:
			raise ImportWarning(
			    '''To use `datasets`, the module `pyarrow>=8.0.0` is required, and the current version of `pyarrow` doesn\'t match this condition.\n'''
			    '''If you are running this in a Google Colab, you should probably just restart the runtime to use the right version of `pyarrow`.'''
			)

del platform
del pyarrow
del version

from .arrow_dataset import Dataset
from .arrow_reader import ReadInstruction
from .builder import ArrowBasedBuilder, BeamBasedBuilder, BuilderConfig, DatasetBuilder, GeneratorBasedBuilder
from .combine import concatenate_datasets, interleave_datasets
from .dataset_dict import DatasetDict, IterableDatasetDict
from .download import *
from .features import *
from .fingerprint import disable_caching, enable_caching, is_caching_enabled, set_caching_enabled
from .info import DatasetInfo, MetricInfo
from .inspect import (
    get_dataset_config_info,
    get_dataset_config_names,
    get_dataset_infos,
    get_dataset_split_names,
    inspect_dataset,
    inspect_metric,
    list_datasets,
    list_metrics,
)
from .iterable_dataset import IterableDataset
from .load import load_dataset, load_dataset_builder, load_from_disk, load_metric
from .metric import Metric
from .splits import (
    NamedSplit,
    NamedSplitAll,
    Split,
    SplitBase,
    SplitDict,
    SplitGenerator,
    SplitInfo,
    SubSplitInfo,
    percent,
)
from .tasks import *
from .utils import *
from .utils import logging


# deprecated modules
from datasets import arrow_dataset as _arrow_dataset  # isort:skip
from datasets import utils as _utils  # isort:skip
from datasets.utils import download_manager as _deprecated_download_manager  # isort:skip

__A				=concatenate_datasets
__A				=DownloadConfig
__A				=DownloadManager
__A				=DownloadMode
__A				=DownloadConfig
__A				=DownloadMode
__A				=DownloadManager

del _arrow_dataset, _utils, _deprecated_download_manager


