



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  ):
     UpperCamelCase__		     =					MODEL_FOR_MASKED_LM_MAPPING
     UpperCamelCase__		     =					TF_MODEL_FOR_MASKED_LM_MAPPING




     def 		snake_case_		(					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 		snake_case_		(					self):
         A__					=       pipeline(task='''fill-mask'''			,    model='''sshleifer/tiny-distilroberta-base'''			,    top_k=2			,    framework='''tf''')
         A__					=       unmasker('''My name is <mask>''')
         self.assertEqual(
             nested_simplify(a__			,    decimals=6)			,    [
                 {'''sequence''': '''My name is grouped''', '''score''': 2.1e-05, '''token''': 3_8_0_1_5, '''token_str''': ''' grouped'''},
                 {'''sequence''': '''My name is accuser''', '''score''': 2.1e-05, '''token''': 2_5_5_0_6, '''token_str''': ''' accuser'''},
             ]			,    )

         A__					=       unmasker('''The largest city in France is <mask>''')
         self.assertEqual(
             nested_simplify(a__			,    decimals=6)			,    [
                 {
                     '''sequence''': '''The largest city in France is grouped''',
                     '''score''': 2.1e-05,
                     '''token''': 3_8_0_1_5,
                     '''token_str''': ''' grouped''',
                 },
                 {
                     '''sequence''': '''The largest city in France is accuser''',
                     '''score''': 2.1e-05,
                     '''token''': 2_5_5_0_6,
                     '''token_str''': ''' accuser''',
                 },
             ]			,    )

         A__					=       unmasker('''My name is <mask>'''			,    targets=[''' Patrick''', ''' Clara''', ''' Teven''']			,    top_k=3)
         self.assertEqual(
             nested_simplify(a__			,    decimals=6)			,    [
                 {'''sequence''': '''My name is Clara''', '''score''': 2e-05, '''token''': 1_3_6_0_6, '''token_str''': ''' Clara'''},
                 {'''sequence''': '''My name is Patrick''', '''score''': 2e-05, '''token''': 3_4_9_9, '''token_str''': ''' Patrick'''},
                 {'''sequence''': '''My name is Te''', '''score''': 1.9e-05, '''token''': 2_9_4_1, '''token_str''': ''' Te'''},
             ]			,    )




     @require_torch
     def 		snake_case_		(					self):
         A__					=       pipeline(task='''fill-mask'''			,    model='''sshleifer/tiny-distilroberta-base'''			,    top_k=2			,    framework='''pt''')

         A__					=       unmasker('''My name is <mask>''')
         self.assertEqual(
             nested_simplify(a__			,    decimals=6)			,    [
                 {'''sequence''': '''My name is Maul''', '''score''': 2.2e-05, '''token''': 3_5_6_7_6, '''token_str''': ''' Maul'''},
                 {'''sequence''': '''My name isELS''', '''score''': 2.2e-05, '''token''': 1_6_4_1_6, '''token_str''': '''ELS'''},
             ]			,    )

         A__					=       unmasker('''The largest city in France is <mask>''')
         self.assertEqual(
             nested_simplify(a__			,    decimals=6)			,    [
                 {
                     '''sequence''': '''The largest city in France is Maul''',
                     '''score''': 2.2e-05,
                     '''token''': 3_5_6_7_6,
                     '''token_str''': ''' Maul''',
                 },
                 {'''sequence''': '''The largest city in France isELS''', '''score''': 2.2e-05, '''token''': 1_6_4_1_6, '''token_str''': '''ELS'''},
             ]			,    )

         A__					=       unmasker('''My name is <mask>'''			,    targets=[''' Patrick''', ''' Clara''', ''' Teven''']			,    top_k=3)
         self.assertEqual(
             nested_simplify(a__			,    decimals=6)			,    [
                 {'''sequence''': '''My name is Patrick''', '''score''': 2.1e-05, '''token''': 3_4_9_9, '''token_str''': ''' Patrick'''},
                 {'''sequence''': '''My name is Te''', '''score''': 2e-05, '''token''': 2_9_4_1, '''token_str''': ''' Te'''},
                 {'''sequence''': '''My name is Clara''', '''score''': 2e-05, '''token''': 1_3_6_0_6, '''token_str''': ''' Clara'''},
             ]			,    )

         A__					=       unmasker('''My name is <mask> <mask>'''			,    top_k=2)

         self.assertEqual(
             nested_simplify(a__			,    decimals=6)			,    [
                 [
                     {
                         '''score''': 2.2e-05,
                         '''token''': 3_5_6_7_6,
                         '''token_str''': ''' Maul''',
                         '''sequence''': '''<s>My name is Maul<mask></s>''',
                     },
                     {'''score''': 2.2e-05, '''token''': 1_6_4_1_6, '''token_str''': '''ELS''', '''sequence''': '''<s>My name isELS<mask></s>'''},
                 ],
                 [
                     {
                         '''score''': 2.2e-05,
                         '''token''': 3_5_6_7_6,
                         '''token_str''': ''' Maul''',
                         '''sequence''': '''<s>My name is<mask> Maul</s>''',
                     },
                     {'''score''': 2.2e-05, '''token''': 1_6_4_1_6, '''token_str''': '''ELS''', '''sequence''': '''<s>My name is<mask>ELS</s>'''},
                 ],
             ]			,    )




     @require_torch_gpu
     def 		snake_case_		(					self):
         A__					=       pipeline('''fill-mask'''			,    model='''hf-internal-testing/tiny-random-distilbert'''			,    device=0			,    framework='''pt''')

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

         A__					=       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(a__			,    a__)




     @slow
     @require_torch
     def 		snake_case_		(					self):
         A__					=       pipeline(task='''fill-mask'''			,    model='''distilroberta-base'''			,    top_k=2			,    framework='''pt''')
         self.run_large_test(a__)




     @slow
     @require_tf
     def 		snake_case_		(					self):
         A__					=       pipeline(task='''fill-mask'''			,    model='''distilroberta-base'''			,    top_k=2			,    framework='''tf''')
         self.run_large_test(a__)




     def 		snake_case_		(					self			,    a__):
         A__					=       unmasker('''My name is <mask>''')
         self.assertEqual(
             nested_simplify(a__)			,    [
                 {'''sequence''': '''My name is John''', '''score''': 0.0_0_8, '''token''': 6_1_0, '''token_str''': ''' John'''},
                 {'''sequence''': '''My name is Chris''', '''score''': 0.0_0_7, '''token''': 1_5_7_3, '''token_str''': ''' Chris'''},
             ]			,    )
         A__					=       unmasker('''The largest city in France is <mask>''')
         self.assertEqual(
             nested_simplify(a__)			,    [
                 {
                     '''sequence''': '''The largest city in France is Paris''',
                     '''score''': 0.2_5_1,
                     '''token''': 2_2_0_1,
                     '''token_str''': ''' Paris''',
                 },
                 {
                     '''sequence''': '''The largest city in France is Lyon''',
                     '''score''': 0.2_1_4,
                     '''token''': 1_2_7_9_0,
                     '''token_str''': ''' Lyon''',
                 },
             ]			,    )

         A__					=       unmasker('''My name is <mask>'''			,    targets=[''' Patrick''', ''' Clara''', ''' Teven''']			,    top_k=3)
         self.assertEqual(
             nested_simplify(a__)			,    [
                 {'''sequence''': '''My name is Patrick''', '''score''': 0.0_0_5, '''token''': 3_4_9_9, '''token_str''': ''' Patrick'''},
                 {'''sequence''': '''My name is Clara''', '''score''': 0.0_0_0, '''token''': 1_3_6_0_6, '''token_str''': ''' Clara'''},
                 {'''sequence''': '''My name is Te''', '''score''': 0.0_0_0, '''token''': 2_9_4_1, '''token_str''': ''' Te'''},
             ]			,    )




     @require_torch
     def 		snake_case_		(					self):
         A__					=       pipeline(task='''fill-mask'''			,    model='''sshleifer/tiny-distilroberta-base'''			,    framework='''pt''')
         A__					=       None
         A__					=       None
         self.run_pipeline_test(a__			,    [])




     @require_tf
     def 		snake_case_		(					self):
         A__					=       pipeline(task='''fill-mask'''			,    model='''sshleifer/tiny-distilroberta-base'''			,    framework='''tf''')
         A__					=       None
         A__					=       None
         self.run_pipeline_test(a__			,    [])




     def 		snake_case_		(					self			,    a__			,    a__			,    a__):
         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__					=       FillMaskPipeline(model=a__			,    tokenizer=a__)
         A__					=       [
             F"This is another {tokenizer.mask_token} test",
         ]
         return fill_masker, examples




     def 		snake_case_		(					self			,    a__			,    a__):
         A__					=       fill_masker.tokenizer
         A__					=       fill_masker.model

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

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

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

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

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




     def 		snake_case_		(					self			,    a__			,    a__):
         A__					=       tokenizer.get_vocab()
         A__					=       sorted(vocab.keys())[:2]
         # Pipeline argument
         A__					=       FillMaskPipeline(model=a__			,    tokenizer=a__			,    targets=a__)
         A__					=       fill_masker(F"This is a {tokenizer.mask_token}")
         self.assertEqual(
             a__			,    [
                 {'''sequence''': ANY(a__), '''score''': ANY(a__), '''token''': ANY(a__), '''token_str''': ANY(a__)},
                 {'''sequence''': ANY(a__), '''score''': ANY(a__), '''token''': ANY(a__), '''token_str''': ANY(a__)},
             ]			,    )
         A__					=       {vocab[el] for el in targets}
         self.assertEqual({el['''token'''] for el in outputs}			,    a__)
         A__					=       [tokenizer.decode([x]) for x in target_ids]
         self.assertEqual({el['''token_str'''] for el in outputs}			,    set(a__))

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

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

         # Raises with invalid
         with self.assertRaises(a__):
             A__					=       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(a__):
                 A__					=       fill_masker(F"This is a {tokenizer.mask_token}"			,    targets=[''''''])
             with self.assertRaises(a__):
                 A__					=       fill_masker(F"This is a {tokenizer.mask_token}"			,    targets='''''')




     def 		snake_case_		(					self			,    a__			,    a__):
         A__					=       FillMaskPipeline(model=a__			,    tokenizer=a__			,    top_k=2)
         A__					=       fill_masker(F"This is a {tokenizer.mask_token}")
         self.assertEqual(
             a__			,    [
                 {'''sequence''': ANY(a__), '''score''': ANY(a__), '''token''': ANY(a__), '''token_str''': ANY(a__)},
                 {'''sequence''': ANY(a__), '''score''': ANY(a__), '''token''': ANY(a__), '''token_str''': ANY(a__)},
             ]			,    )

         A__					=       FillMaskPipeline(model=a__			,    tokenizer=a__)
         A__					=       fill_masker(F"This is a {tokenizer.mask_token}"			,    top_k=2)
         self.assertEqual(
             a__			,    [
                 {'''sequence''': ANY(a__), '''score''': ANY(a__), '''token''': ANY(a__), '''token_str''': ANY(a__)},
                 {'''sequence''': ANY(a__), '''score''': ANY(a__), '''token''': ANY(a__), '''token_str''': ANY(a__)},
             ]			,    )
         self.assertEqual(nested_simplify(a__)			,    nested_simplify(a__))




     def 		snake_case_		(					self			,    a__			,    a__):
         A__					=       tokenizer.get_vocab()
         A__					=       FillMaskPipeline(model=a__			,    tokenizer=a__)

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

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




     def 		snake_case_		(					self			,    a__			,    a__):
         A__					=       FillMaskPipeline(model=a__			,    tokenizer=a__)
         A__					=       tokenizer.get_vocab()
         # String duplicates + id duplicates
         A__					=       sorted(vocab.keys())[:3]
         A__					=       [targets[0], targets[1], targets[0], targets[2], targets[1]]
         A__					=       fill_masker(F"My name is {tokenizer.mask_token}"			,    targets=a__			,    top_k=1_0)

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




     def 		snake_case_		(					self			,    a__			,    a__):
         A__					=       FillMaskPipeline(model=a__			,    tokenizer=a__)

         A__					=       fill_masker(
             F"This is a {tokenizer.mask_token} {tokenizer.mask_token} {tokenizer.mask_token}"			,    top_k=2)
         self.assertEqual(
             a__			,    [
                 [
                     {'''sequence''': ANY(a__), '''score''': ANY(a__), '''token''': ANY(a__), '''token_str''': ANY(a__)},
                     {'''sequence''': ANY(a__), '''score''': ANY(a__), '''token''': ANY(a__), '''token_str''': ANY(a__)},
                 ],
                 [
                     {'''sequence''': ANY(a__), '''score''': ANY(a__), '''token''': ANY(a__), '''token_str''': ANY(a__)},
                     {'''sequence''': ANY(a__), '''score''': ANY(a__), '''token''': ANY(a__), '''token_str''': ANY(a__)},
                 ],
                 [
                     {'''sequence''': ANY(a__), '''score''': ANY(a__), '''token''': ANY(a__), '''token_str''': ANY(a__)},
                     {'''sequence''': ANY(a__), '''score''': ANY(a__), '''token''': ANY(a__), '''token_str''': ANY(a__)},
                 ],
             ]			,    )






'''simple docstring'''


import copy
from dataclasses import dataclass, field
from typing import ClassVar, Dict

from ..features import Audio, ClassLabel, Features
from .base import TaskTemplate





@dataclass(frozen=__magic_name__			)
class  __lowercase    (	__magic_name__			):
   _a    						=   field(default="""audio-classification"""							,				metadata={"""include_in_asdict_even_if_is_default""": True}			)
   _a    						=   Features({"""audio""": Audio()}			)
   _a    						=   Features({"""labels""": ClassLabel}			)
   _a    						=   "audio"
   _a    						=   "labels"







   def 		UpperCamelCase__      (						self   ,				UpperCamelCase   )					->     Dict:
     if self.label_column not in features:
       raise ValueError(f"Column {self.label_column} is not present in features."   )
     if not isinstance(features[self.label_column]   ,				UpperCamelCase   ):
       raise ValueError(f"Column {self.label_column} is not a ClassLabel."   )
     __a								=       copy.deepcopy(self   )
     __a								=       self.label_schema.copy()
     __a								=       features[self.label_column]
     __a								=       label_schema
     return task_template







   @property
   def 		UpperCamelCase__      (						self   )					->     Dict[str, str]:
     return {
         self.audio_column: "audio",
         self.label_column: "labels",
     }



