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 __snake_case       (		unittest.TestCase	):
   lowerCAmelCase_														=							MODEL_FOR_MASKED_LM_MAPPING
   lowerCAmelCase_														=							TF_MODEL_FOR_MASKED_LM_MAPPING




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



     """simple docstring"""






     SCREAMING_SNAKE_CASE__    							=   pipeline(task="""fill-mask""" ,			model="""sshleifer/tiny-distilroberta-base""" ,			top_k=2 ,			framework="""tf"""   )
     SCREAMING_SNAKE_CASE__    							=   unmasker("""My name is <mask>"""   )
     self.assertEqual(
         nested_simplify(_lowercase ,			decimals=6   ) ,			[
             {"""sequence""": """My name is grouped""", """score""": 2.1E-05, """token""": 3_80_15, """token_str""": """ grouped"""},
             {"""sequence""": """My name is accuser""", """score""": 2.1E-05, """token""": 2_55_06, """token_str""": """ accuser"""},
         ] ,			)

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

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




   @require_torch
   def 			__a		(					self    :       Any   ):



     """simple docstring"""






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

     SCREAMING_SNAKE_CASE__    							=   unmasker("""My name is <mask>"""   )
     self.assertEqual(
         nested_simplify(_lowercase ,			decimals=6   ) ,			[
             {"""sequence""": """My name is Maul""", """score""": 2.2E-05, """token""": 3_56_76, """token_str""": """ Maul"""},
             {"""sequence""": """My name isELS""", """score""": 2.2E-05, """token""": 1_64_16, """token_str""": """ELS"""},
         ] ,			)

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

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

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

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




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



     """simple docstring"""






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

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

     SCREAMING_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(_lowercase ,			_lowercase   )




   @slow
   @require_torch
   def 			__a		(					self    :       Any   ):



     """simple docstring"""






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




   @slow
   @require_tf
   def 			__a		(					self    :       List[str]   ):



     """simple docstring"""






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




   def 			__a		(					self    :       str ,			_lowercase    :       Union[str, Any]   ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__    							=   unmasker("""My name is <mask>"""   )
     self.assertEqual(
         nested_simplify(_lowercase   ) ,			[
             {"""sequence""": """My name is John""", """score""": 0.0_08, """token""": 6_10, """token_str""": """ John"""},
             {"""sequence""": """My name is Chris""", """score""": 0.0_07, """token""": 15_73, """token_str""": """ Chris"""},
         ] ,			)
     SCREAMING_SNAKE_CASE__    							=   unmasker("""The largest city in France is <mask>"""   )
     self.assertEqual(
         nested_simplify(_lowercase   ) ,			[
             {
                 """sequence""": """The largest city in France is Paris""",
                 """score""": 0.2_51,
                 """token""": 22_01,
                 """token_str""": """ Paris""",
             },
             {
                 """sequence""": """The largest city in France is Lyon""",
                 """score""": 0.2_14,
                 """token""": 1_27_90,
                 """token_str""": """ Lyon""",
             },
         ] ,			)

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




   @require_torch
   def 			__a		(					self    :       Optional[Any]   ):



     """simple docstring"""






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




   @require_tf
   def 			__a		(					self    :       Tuple   ):



     """simple docstring"""






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




   def 			__a		(					self    :       str ,			_lowercase    :       int ,			_lowercase    :       str ,			_lowercase    :       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)"""   )

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




   def 			__a		(					self    :       Any ,			_lowercase    :       Union[str, Any] ,			_lowercase    :       Optional[Any]   ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__    							=   fill_masker.tokenizer
     SCREAMING_SNAKE_CASE__    							=   fill_masker.model

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

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

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

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

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




   def 			__a		(					self    :       List[str] ,			_lowercase    :       str ,			_lowercase    :       Union[str, Any]   ):



     """simple docstring"""






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

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

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

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




   def 			__a		(					self    :       List[str] ,			_lowercase    :       List[str] ,			_lowercase    :       Union[str, Any]   ):



     """simple docstring"""






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

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




   def 			__a		(					self    :       Any ,			_lowercase    :       Dict ,			_lowercase    :       Tuple   ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__    							=   tokenizer.get_vocab()
     SCREAMING_SNAKE_CASE__    							=   FillMaskPipeline(model=_lowercase ,			tokenizer=_lowercase   )

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

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




   def 			__a		(					self    :       Optional[Any] ,			_lowercase    :       str ,			_lowercase    :       Union[str, Any]   ):



     """simple docstring"""






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

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




   def 			__a		(					self    :       Optional[Any] ,			_lowercase    :       Optional[int] ,			_lowercase    :       str   ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__    							=   FillMaskPipeline(model=_lowercase ,			tokenizer=_lowercase   )

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

from typing import TYPE_CHECKING

# rely on isort to merge the imports
from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


__lowerCamelCase    :				List[Any]							     =	{
    '''configuration_informer''': [
        '''INFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP''',
        '''InformerConfig''',
    ],
}

try:
   if not is_torch_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   __lowerCamelCase    :				Union[str, Any]							     =	[
       '''INFORMER_PRETRAINED_MODEL_ARCHIVE_LIST''',
       '''InformerForPrediction''',
       '''InformerModel''',
       '''InformerPreTrainedModel''',
   ]


if TYPE_CHECKING:
   from .configuration_informer import INFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP, InformerConfig

   try:
      if not is_torch_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_informer import (
          INFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
          InformerForPrediction,
          InformerModel,
          InformerPreTrainedModel,
      )

else:
   import sys

   __lowerCamelCase    :				Dict							     =	_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
