

"""simple docstring"""



import gc
import unittest

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

from .test_pipelines_common import ANY



@is_pipeline_test
class 					a						(       unittest.TestCase				):



    """simple docstring"""



    UpperCAmelCase						 =					MODEL_FOR_MASKED_LM_MAPPING
    UpperCAmelCase						 =					TF_MODEL_FOR_MASKED_LM_MAPPING

    def 				UpperCamelCase	(     self: List[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 				UpperCamelCase	(     self: str       ):






         """simple docstring"""


         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(UpperCamelCase    ,						decimals=6       )    ,						[
                 {"""sequence""": """My name is grouped""", """score""": 2.1e-0_5, """token""": 3_80_15, """token_str""": """ grouped"""},
                 {"""sequence""": """My name is accuser""", """score""": 2.1e-0_5, """token""": 2_55_06, """token_str""": """ accuser"""},
             ]    ,						)

         A__										=  unmasker("""The largest city in France is <mask>"""       )
         self.assertEqual(
             nested_simplify(UpperCamelCase    ,						decimals=6       )    ,						[
                 {
                     """sequence""": """The largest city in France is grouped""",
                     """score""": 2.1e-0_5,
                     """token""": 3_80_15,
                     """token_str""": """ grouped""",
                 },
                 {
                     """sequence""": """The largest city in France is accuser""",
                     """score""": 2.1e-0_5,
                     """token""": 2_55_06,
                     """token_str""": """ accuser""",
                 },
             ]    ,						)

         A__										=  unmasker("""My name is <mask>"""    ,						targets=[""" Patrick""", """ Clara""", """ Teven"""]    ,						top_k=3       )
         self.assertEqual(
             nested_simplify(UpperCamelCase    ,						decimals=6       )    ,						[
                 {"""sequence""": """My name is Clara""", """score""": 2e-0_5, """token""": 1_36_06, """token_str""": """ Clara"""},
                 {"""sequence""": """My name is Patrick""", """score""": 2e-0_5, """token""": 34_99, """token_str""": """ Patrick"""},
                 {"""sequence""": """My name is Te""", """score""": 1.9e-0_5, """token""": 29_41, """token_str""": """ Te"""},
             ]    ,						)

    @require_torch
    def 				UpperCamelCase	(     self: int       ):






         """simple docstring"""


         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(UpperCamelCase    ,						decimals=6       )    ,						[
                 {"""sequence""": """My name is Maul""", """score""": 2.2e-0_5, """token""": 3_56_76, """token_str""": """ Maul"""},
                 {"""sequence""": """My name isELS""", """score""": 2.2e-0_5, """token""": 1_64_16, """token_str""": """ELS"""},
             ]    ,						)

         A__										=  unmasker("""The largest city in France is <mask>"""       )
         self.assertEqual(
             nested_simplify(UpperCamelCase    ,						decimals=6       )    ,						[
                 {
                     """sequence""": """The largest city in France is Maul""",
                     """score""": 2.2e-0_5,
                     """token""": 3_56_76,
                     """token_str""": """ Maul""",
                 },
                 {"""sequence""": """The largest city in France isELS""", """score""": 2.2e-0_5, """token""": 1_64_16, """token_str""": """ELS"""},
             ]    ,						)

         A__										=  unmasker("""My name is <mask>"""    ,						targets=[""" Patrick""", """ Clara""", """ Teven"""]    ,						top_k=3       )
         self.assertEqual(
             nested_simplify(UpperCamelCase    ,						decimals=6       )    ,						[
                 {"""sequence""": """My name is Patrick""", """score""": 2.1e-0_5, """token""": 34_99, """token_str""": """ Patrick"""},
                 {"""sequence""": """My name is Te""", """score""": 2e-0_5, """token""": 29_41, """token_str""": """ Te"""},
                 {"""sequence""": """My name is Clara""", """score""": 2e-0_5, """token""": 1_36_06, """token_str""": """ Clara"""},
             ]    ,						)

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

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

    @require_torch_gpu
    def 				UpperCamelCase	(     self: Union[str, Any]       ):






         """simple docstring"""


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

    @slow
    @require_torch
    def 				UpperCamelCase	(     self: List[str]       ):






         """simple docstring"""


         A__										=  pipeline(task="""fill-mask"""    ,						model="""distilroberta-base"""    ,						top_k=2    ,						framework="""pt"""       )
         self.run_large_test(UpperCamelCase       )

    @slow
    @require_tf
    def 				UpperCamelCase	(     self: Tuple       ):






         """simple docstring"""


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

    def 				UpperCamelCase	(     self: str    ,						UpperCamelCase: Union[str, Any]       ):






         """simple docstring"""


         A__										=  unmasker("""My name is <mask>"""       )
         self.assertEqual(
             nested_simplify(UpperCamelCase       )    ,						[
                 {"""sequence""": """My name is John""", """score""": 0.008, """token""": 6_10, """token_str""": """ John"""},
                 {"""sequence""": """My name is Chris""", """score""": 0.007, """token""": 15_73, """token_str""": """ Chris"""},
             ]    ,						)
         A__										=  unmasker("""The largest city in France is <mask>"""       )
         self.assertEqual(
             nested_simplify(UpperCamelCase       )    ,						[
                 {
                     """sequence""": """The largest city in France is Paris""",
                     """score""": 0.251,
                     """token""": 22_01,
                     """token_str""": """ Paris""",
                 },
                 {
                     """sequence""": """The largest city in France is Lyon""",
                     """score""": 0.214,
                     """token""": 1_27_90,
                     """token_str""": """ Lyon""",
                 },
             ]    ,						)

         A__										=  unmasker("""My name is <mask>"""    ,						targets=[""" Patrick""", """ Clara""", """ Teven"""]    ,						top_k=3       )
         self.assertEqual(
             nested_simplify(UpperCamelCase       )    ,						[
                 {"""sequence""": """My name is Patrick""", """score""": 0.005, """token""": 34_99, """token_str""": """ Patrick"""},
                 {"""sequence""": """My name is Clara""", """score""": 0.000, """token""": 1_36_06, """token_str""": """ Clara"""},
                 {"""sequence""": """My name is Te""", """score""": 0.000, """token""": 29_41, """token_str""": """ Te"""},
             ]    ,						)

    @require_torch
    def 				UpperCamelCase	(     self: Optional[int]       ):






         """simple docstring"""


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

    @require_tf
    def 				UpperCamelCase	(     self: str       ):






         """simple docstring"""


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

    def 				UpperCamelCase	(     self: int    ,						UpperCamelCase: Any    ,						UpperCamelCase: Optional[int]    ,						UpperCamelCase: Dict       ):






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

         A__										=  FillMaskPipeline(model=UpperCamelCase    ,						tokenizer=UpperCamelCase       )
         A__										=  [
             f"""This is another {tokenizer.mask_token} test""",
         ]
         return fill_masker, examples

    def 				UpperCamelCase	(     self: List[str]    ,						UpperCamelCase: Tuple    ,						UpperCamelCase: List[str]       ):






         """simple docstring"""


         A__										=  fill_masker.tokenizer
         A__										=  fill_masker.model

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

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

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

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

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

    def 				UpperCamelCase	(     self: Tuple    ,						UpperCamelCase: Union[str, Any]    ,						UpperCamelCase: Optional[Any]       ):






         """simple docstring"""


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

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

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

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

    def 				UpperCamelCase	(     self: List[str]    ,						UpperCamelCase: int    ,						UpperCamelCase: Union[str, Any]       ):






         """simple docstring"""


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

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

    def 				UpperCamelCase	(     self: Dict    ,						UpperCamelCase: List[Any]    ,						UpperCamelCase: Dict       ):






         """simple docstring"""


         A__										=  tokenizer.get_vocab()
         A__										=  FillMaskPipeline(model=UpperCamelCase    ,						tokenizer=UpperCamelCase       )

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

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

    def 				UpperCamelCase	(     self: List[Any]    ,						UpperCamelCase: Any    ,						UpperCamelCase: Any       ):






         """simple docstring"""


         A__										=  FillMaskPipeline(model=UpperCamelCase    ,						tokenizer=UpperCamelCase       )
         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=UpperCamelCase    ,						top_k=10       )

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





    def 				UpperCamelCase	(     self: Dict    ,						UpperCamelCase: List[Any]    ,						UpperCamelCase: Union[str, Any]       ):






         """simple docstring"""


         A__										=  FillMaskPipeline(model=UpperCamelCase    ,						tokenizer=UpperCamelCase       )

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









"""simple docstring"""



import warnings

from ...utils import logging
from .image_processing_videomae import VideoMAEImageProcessor


SCREAMING_SNAKE_CASE_					:	List[Any]							  =						logging.get_logger(__name__)



class 					a						(       _lowerCamelCase				):



    """simple docstring"""



    def __init__(     self: Tuple    ,						*UpperCamelCase: Optional[int]    ,						**UpperCamelCase: Tuple       ):






         """simple docstring"""


         warnings.warn(
             """The class VideoMAEFeatureExtractor is deprecated and will be removed in version 5 of Transformers."""
             """ Please use VideoMAEImageProcessor instead."""    ,						UpperCamelCase    ,						)
         super().__init__(*UpperCamelCase    ,						**UpperCamelCase       )






