
"""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'''
  SCREAMING_SNAKE_CASE__			:						Union[str, Any]       =		MODEL_FOR_MASKED_LM_MAPPING
  SCREAMING_SNAKE_CASE__			:						Optional[int]       =		TF_MODEL_FOR_MASKED_LM_MAPPING







  def        UpperCamelCase__					(		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        UpperCamelCase__					(		self  ):

     """simple docstring"""
     UpperCAmelCase_					:					Union[str, Any]			     =    pipeline(task="fill-mask"				,   model="sshleifer/tiny-distilroberta-base"				,   top_k=2				,   framework="tf"  )
     UpperCAmelCase_					:					Optional[int]			     =    unmasker("My name is <mask>"  )
     self.assertEqual(
         nested_simplify(lowercase_				,   decimals=6  )				,   [
             {"sequence": "My name is grouped", "score": 2.1E-0_5, "token": 3_8015, "token_str": " grouped"},
             {"sequence": "My name is accuser", "score": 2.1E-0_5, "token": 2_5506, "token_str": " accuser"},
         ]				,   )

     UpperCAmelCase_					:					List[Any]			     =    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-0_5,
                 "token": 3_8015,
                 "token_str": " grouped",
             },
             {
                 "sequence": "The largest city in France is accuser",
                 "score": 2.1E-0_5,
                 "token": 2_5506,
                 "token_str": " accuser",
             },
         ]				,   )

     UpperCAmelCase_					:					str			     =    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-0_5, "token": 1_3606, "token_str": " Clara"},
             {"sequence": "My name is Patrick", "score": 2E-0_5, "token": 3499, "token_str": " Patrick"},
             {"sequence": "My name is Te", "score": 1.9E-0_5, "token": 2941, "token_str": " Te"},
         ]				,   )







  @require_torch
  def        UpperCamelCase__					(		self  ):

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

     UpperCAmelCase_					:					Union[str, Any]			     =    unmasker("My name is <mask>"  )
     self.assertEqual(
         nested_simplify(lowercase_				,   decimals=6  )				,   [
             {"sequence": "My name is Maul", "score": 2.2E-0_5, "token": 3_5676, "token_str": " Maul"},
             {"sequence": "My name isELS", "score": 2.2E-0_5, "token": 1_6416, "token_str": "ELS"},
         ]				,   )

     UpperCAmelCase_					:					Union[str, Any]			     =    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-0_5,
                 "token": 3_5676,
                 "token_str": " Maul",
             },
             {"sequence": "The largest city in France isELS", "score": 2.2E-0_5, "token": 1_6416, "token_str": "ELS"},
         ]				,   )

     UpperCAmelCase_					:					int			     =    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-0_5, "token": 3499, "token_str": " Patrick"},
             {"sequence": "My name is Te", "score": 2E-0_5, "token": 2941, "token_str": " Te"},
             {"sequence": "My name is Clara", "score": 2E-0_5, "token": 1_3606, "token_str": " Clara"},
         ]				,   )

     UpperCAmelCase_					:					Optional[Any]			     =    unmasker("My name is <mask> <mask>"				,   top_k=2  )

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







  @require_torch_gpu
  def        UpperCamelCase__					(		self  ):

     """simple docstring"""
     UpperCAmelCase_					:					List[Any]			     =    pipeline("fill-mask"				,   model="hf-internal-testing/tiny-random-distilbert"				,   device=0				,   framework="pt"  )

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

     UpperCAmelCase_					:					Dict			     =    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        UpperCamelCase__					(		self  ):

     """simple docstring"""
     UpperCAmelCase_					:					Tuple			     =    pipeline(task="fill-mask"				,   model="distilroberta-base"				,   top_k=2				,   framework="pt"  )
     self.run_large_test(lowercase_  )







  @slow
  @require_tf
  def        UpperCamelCase__					(		self  ):

     """simple docstring"""
     UpperCAmelCase_					:					Optional[Any]			     =    pipeline(task="fill-mask"				,   model="distilroberta-base"				,   top_k=2				,   framework="tf"  )
     self.run_large_test(lowercase_  )







  def        UpperCamelCase__					(		self				,   lowercase_  ):

     """simple docstring"""
     UpperCAmelCase_					:					int			     =    unmasker("My name is <mask>"  )
     self.assertEqual(
         nested_simplify(lowercase_  )				,   [
             {"sequence": "My name is John", "score": 0.0_08, "token": 610, "token_str": " John"},
             {"sequence": "My name is Chris", "score": 0.0_07, "token": 1573, "token_str": " Chris"},
         ]				,   )
     UpperCAmelCase_					:					Optional[Any]			     =    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": 2201,
                 "token_str": " Paris",
             },
             {
                 "sequence": "The largest city in France is Lyon",
                 "score": 0.2_14,
                 "token": 1_2790,
                 "token_str": " Lyon",
             },
         ]				,   )

     UpperCAmelCase_					:					Optional[int]			     =    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": 3499, "token_str": " Patrick"},
             {"sequence": "My name is Clara", "score": 0.0_00, "token": 1_3606, "token_str": " Clara"},
             {"sequence": "My name is Te", "score": 0.0_00, "token": 2941, "token_str": " Te"},
         ]				,   )







  @require_torch
  def        UpperCamelCase__					(		self  ):

     """simple docstring"""
     UpperCAmelCase_					:					str			     =    pipeline(task="fill-mask"				,   model="sshleifer/tiny-distilroberta-base"				,   framework="pt"  )
     UpperCAmelCase_					:					Any			     =    None
     UpperCAmelCase_					:					Dict			     =    None
     self.run_pipeline_test(lowercase_				,   []  )







  @require_tf
  def        UpperCamelCase__					(		self  ):

     """simple docstring"""
     UpperCAmelCase_					:					Tuple			     =    pipeline(task="fill-mask"				,   model="sshleifer/tiny-distilroberta-base"				,   framework="tf"  )
     UpperCAmelCase_					:					Dict			     =    None
     UpperCAmelCase_					:					List[Any]			     =    None
     self.run_pipeline_test(lowercase_				,   []  )







  def        UpperCamelCase__					(		self				,   lowercase_				,   lowercase_				,   lowercase_  ):

     """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_					:					Union[str, Any]			     =    FillMaskPipeline(model=lowercase_				,   tokenizer=lowercase_  )
     UpperCAmelCase_					:					Tuple			     =    [
         F"""This is another {tokenizer.mask_token} test""",
     ]
     return fill_masker, examples







  def        UpperCamelCase__					(		self				,   lowercase_				,   lowercase_  ):

     """simple docstring"""
     UpperCAmelCase_					:					List[str]			     =    fill_masker.tokenizer
     UpperCAmelCase_					:					List[Any]			     =    fill_masker.model

     UpperCAmelCase_					:					Union[str, Any]			     =    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_  )},
         ]				,   )

     UpperCAmelCase_					:					Dict			     =    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_  )},
         ]				,   )

     UpperCAmelCase_					:					Any			     =    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        UpperCamelCase__					(		self				,   lowercase_				,   lowercase_  ):

     """simple docstring"""
     UpperCAmelCase_					:					str			     =    tokenizer.get_vocab()
     UpperCAmelCase_					:					Dict			     =    sorted(vocab.keys()  )[:2]
     # Pipeline argument
     UpperCAmelCase_					:					Any			     =    FillMaskPipeline(model=lowercase_				,   tokenizer=lowercase_				,   targets=lowercase_  )
     UpperCAmelCase_					:					int			     =    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_  )},
         ]				,   )
     UpperCAmelCase_					:					int			     =    {vocab[el] for el in targets}
     self.assertEqual({el["token"] for el in outputs}				,   lowercase_  )
     UpperCAmelCase_					:					Any			     =    [tokenizer.decode([x]  ) for x in target_ids]
     self.assertEqual({el["token_str"] for el in outputs}				,   set(lowercase_  )  )

     # Call argument
     UpperCAmelCase_					:					str			     =    FillMaskPipeline(model=lowercase_				,   tokenizer=lowercase_  )
     UpperCAmelCase_					:					Dict			     =    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_  )},
         ]				,   )
     UpperCAmelCase_					:					Union[str, Any]			     =    {vocab[el] for el in targets}
     self.assertEqual({el["token"] for el in outputs}				,   lowercase_  )
     UpperCAmelCase_					:					str			     =    [tokenizer.decode([x]  ) for x in target_ids]
     self.assertEqual({el["token_str"] for el in outputs}				,   set(lowercase_  )  )

     # Score equivalence
     UpperCAmelCase_					:					Optional[Any]			     =    fill_masker(F"""This is a {tokenizer.mask_token}"""				,   targets=lowercase_  )
     UpperCAmelCase_					:					Tuple			     =    [top_mask["""token_str"""] for top_mask in outputs]
     UpperCAmelCase_					:					Union[str, Any]			     =    [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_  ):
        UpperCAmelCase_					:					Any			     =    fill_masker(F"""This is a {tokenizer.mask_token}"""				,   targets=lowercase_  )
        UpperCAmelCase_					:					Optional[Any]			     =    [top_mask["""score"""] for top_mask in unmasked_targets]
        self.assertEqual(nested_simplify(lowercase_  )				,   nested_simplify(lowercase_  )  )

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







  def        UpperCamelCase__					(		self				,   lowercase_				,   lowercase_  ):

     """simple docstring"""
     UpperCAmelCase_					:					List[Any]			     =    FillMaskPipeline(model=lowercase_				,   tokenizer=lowercase_				,   top_k=2  )
     UpperCAmelCase_					:					str			     =    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_  )},
         ]				,   )

     UpperCAmelCase_					:					str			     =    FillMaskPipeline(model=lowercase_				,   tokenizer=lowercase_  )
     UpperCAmelCase_					:					Any			     =    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        UpperCamelCase__					(		self				,   lowercase_				,   lowercase_  ):

     """simple docstring"""
     UpperCAmelCase_					:					Dict			     =    tokenizer.get_vocab()
     UpperCAmelCase_					:					List[Any]			     =    FillMaskPipeline(model=lowercase_				,   tokenizer=lowercase_  )

     # top_k=2, ntargets=3
     UpperCAmelCase_					:					Any			     =    sorted(vocab.keys()  )[:3]
     UpperCAmelCase_					:					Optional[Any]			     =    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
     UpperCAmelCase_					:					str			     =    [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_  ):
        UpperCAmelCase_					:					Tuple			     =    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        UpperCamelCase__					(		self				,   lowercase_				,   lowercase_  ):

     """simple docstring"""
     UpperCAmelCase_					:					Optional[Any]			     =    FillMaskPipeline(model=lowercase_				,   tokenizer=lowercase_  )
     UpperCAmelCase_					:					List[Any]			     =    tokenizer.get_vocab()
     # String duplicates + id duplicates
     UpperCAmelCase_					:					int			     =    sorted(vocab.keys()  )[:3]
     UpperCAmelCase_					:					Optional[int]			     =    [targets[0], targets[1], targets[0], targets[2], targets[1]]
     UpperCAmelCase_					:					Tuple			     =    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        UpperCamelCase__					(		self				,   lowercase_				,   lowercase_  ):

     """simple docstring"""
     UpperCAmelCase_					:					List[Any]			     =    FillMaskPipeline(model=lowercase_				,   tokenizer=lowercase_  )

     UpperCAmelCase_					:					int			     =    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_  )},
             ],
         ]				,   )



'''simple docstring'''




from typing import TYPE_CHECKING

from ....utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


_lowercase						: Dict						=						{"configuration_mmbt": ["MMBTConfig"]}

try:
						if not is_torch_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						_lowercase						: Dict						=						["MMBTForClassification", "MMBTModel", "ModalEmbeddings"]


if TYPE_CHECKING:
						from .configuration_mmbt import MMBTConfig

						try:
												if not is_torch_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_mmbt import MMBTForClassification, MMBTModel, ModalEmbeddings

else:
						import sys

						_lowercase						: Optional[int]						=						_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)





