
import copy
import unittest

from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
							import torch

							from transformers import (
							    MODEL_FOR_MULTIPLE_CHOICE_MAPPING,
							    MODEL_FOR_QUESTION_ANSWERING_MAPPING,
							    MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
							    MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
							    LayoutLMvaConfig,
							    LayoutLMvaForQuestionAnswering,
							    LayoutLMvaForSequenceClassification,
							    LayoutLMvaForTokenClassification,
							    LayoutLMvaModel,
							)
							from transformers.models.layoutlmva.modeling_layoutlmva import LAYOUTLMV3_PRETRAINED_MODEL_ARCHIVE_LIST

if is_vision_available():
							from PIL import Image

							from transformers import LayoutLMvaImageProcessor





class 							lowerCAmelCase_						:




			'''simple docstring'''


			def __init__(	self    ,							__UpperCAmelCase    ,							__UpperCAmelCase=2    ,							__UpperCAmelCase=3    ,							__UpperCAmelCase=4    ,							__UpperCAmelCase=2    ,							__UpperCAmelCase=7    ,							__UpperCAmelCase=True    ,							__UpperCAmelCase=True    ,							__UpperCAmelCase=True    ,							__UpperCAmelCase=True    ,							__UpperCAmelCase=99    ,							__UpperCAmelCase=36    ,							__UpperCAmelCase=3    ,							__UpperCAmelCase=4    ,							__UpperCAmelCase=37    ,							__UpperCAmelCase="gelu"    ,							__UpperCAmelCase=0.1    ,							__UpperCAmelCase=0.1    ,							__UpperCAmelCase=512    ,							__UpperCAmelCase=16    ,							__UpperCAmelCase=2    ,							__UpperCAmelCase=0.02    ,							__UpperCAmelCase=6    ,							__UpperCAmelCase=6    ,							__UpperCAmelCase=3    ,							__UpperCAmelCase=4    ,							__UpperCAmelCase=None    ,							__UpperCAmelCase=1_000    ,							):
										SCREAMING_SNAKE_CASE_	:							int											=parent
										SCREAMING_SNAKE_CASE_	:							str											=batch_size
										SCREAMING_SNAKE_CASE_	:							Optional[Any]											=num_channels
										SCREAMING_SNAKE_CASE_	:							Optional[int]											=image_size
										SCREAMING_SNAKE_CASE_	:							Dict											=patch_size
										SCREAMING_SNAKE_CASE_	:							Union[str, Any]											=text_seq_length
										SCREAMING_SNAKE_CASE_	:							int											=is_training
										SCREAMING_SNAKE_CASE_	:							int											=use_input_mask
										SCREAMING_SNAKE_CASE_	:							str											=use_token_type_ids
										SCREAMING_SNAKE_CASE_	:							str											=use_labels
										SCREAMING_SNAKE_CASE_	:							Any											=vocab_size
										SCREAMING_SNAKE_CASE_	:							Optional[Any]											=hidden_size
										SCREAMING_SNAKE_CASE_	:							str											=num_hidden_layers
										SCREAMING_SNAKE_CASE_	:							int											=num_attention_heads
										SCREAMING_SNAKE_CASE_	:							Tuple											=intermediate_size
										SCREAMING_SNAKE_CASE_	:							Dict											=hidden_act
										SCREAMING_SNAKE_CASE_	:							Optional[int]											=hidden_dropout_prob
										SCREAMING_SNAKE_CASE_	:							List[Any]											=attention_probs_dropout_prob
										SCREAMING_SNAKE_CASE_	:							int											=max_position_embeddings
										SCREAMING_SNAKE_CASE_	:							List[Any]											=type_vocab_size
										SCREAMING_SNAKE_CASE_	:							Union[str, Any]											=type_sequence_label_size
										SCREAMING_SNAKE_CASE_	:							List[Any]											=initializer_range
										SCREAMING_SNAKE_CASE_	:							Tuple											=coordinate_size
										SCREAMING_SNAKE_CASE_	:							int											=shape_size
										SCREAMING_SNAKE_CASE_	:							List[str]											=num_labels
										SCREAMING_SNAKE_CASE_	:							Any											=num_choices
										SCREAMING_SNAKE_CASE_	:							str											=scope
										SCREAMING_SNAKE_CASE_	:							Tuple											=range_bbox

										# LayoutLMv3's sequence length equals the number of text tokens + number of patches + 1 (we add 1 for the CLS token)
										SCREAMING_SNAKE_CASE_	:							Optional[Any]											=text_seq_length
										SCREAMING_SNAKE_CASE_	:							int											=(image_size // patch_size) ** 2 + 1
										SCREAMING_SNAKE_CASE_	:							List[str]											=self.text_seq_length + self.image_seq_length







			def      __lowerCamelCase    (	self  ):
										SCREAMING_SNAKE_CASE_	:							Union[str, Any]											=ids_tensor([self.batch_size, self.text_seq_length]    ,							self.vocab_size  )

										SCREAMING_SNAKE_CASE_	:							List[str]											=ids_tensor([self.batch_size, self.text_seq_length, 4]    ,							self.range_bbox  )
										# Ensure that bbox is legal
										for i in range(bbox.shape[0]  ):
																	for j in range(bbox.shape[1]  ):
																								if bbox[i, j, 3] < bbox[i, j, 1]:
																															SCREAMING_SNAKE_CASE_	:							Union[str, Any]											=bbox[i, j, 3]
																															SCREAMING_SNAKE_CASE_	:							Any											=bbox[i, j, 1]
																															SCREAMING_SNAKE_CASE_	:							List[str]											=t
																								if bbox[i, j, 2] < bbox[i, j, 0]:
																															SCREAMING_SNAKE_CASE_	:							Dict											=bbox[i, j, 2]
																															SCREAMING_SNAKE_CASE_	:							Dict											=bbox[i, j, 0]
																															SCREAMING_SNAKE_CASE_	:							Any											=t

										SCREAMING_SNAKE_CASE_	:							Optional[Any]											=floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]  )

										SCREAMING_SNAKE_CASE_	:							str											=None
										if self.use_input_mask:
																	SCREAMING_SNAKE_CASE_	:							Optional[Any]											=random_attention_mask([self.batch_size, self.text_seq_length]  )

										SCREAMING_SNAKE_CASE_	:							str											=None
										if self.use_token_type_ids:
																	SCREAMING_SNAKE_CASE_	:							Optional[int]											=ids_tensor([self.batch_size, self.text_seq_length]    ,							self.type_vocab_size  )

										SCREAMING_SNAKE_CASE_	:							List[Any]											=None
										SCREAMING_SNAKE_CASE_	:							List[str]											=None
										if self.use_labels:
																	SCREAMING_SNAKE_CASE_	:							List[Any]											=ids_tensor([self.batch_size]    ,							self.type_sequence_label_size  )
																	SCREAMING_SNAKE_CASE_	:							Dict											=ids_tensor([self.batch_size, self.text_seq_length]    ,							self.num_labels  )

										SCREAMING_SNAKE_CASE_	:							Union[str, Any]											=LayoutLMvaConfig(
										    vocab_size=self.vocab_size    ,							hidden_size=self.hidden_size    ,							num_hidden_layers=self.num_hidden_layers    ,							num_attention_heads=self.num_attention_heads    ,							intermediate_size=self.intermediate_size    ,							hidden_act=self.hidden_act    ,							hidden_dropout_prob=self.hidden_dropout_prob    ,							attention_probs_dropout_prob=self.attention_probs_dropout_prob    ,							max_position_embeddings=self.max_position_embeddings    ,							type_vocab_size=self.type_vocab_size    ,							initializer_range=self.initializer_range    ,							coordinate_size=self.coordinate_size    ,							shape_size=self.shape_size    ,							input_size=self.image_size    ,							patch_size=self.patch_size    ,							)

										return config, input_ids, bbox, pixel_values, token_type_ids, input_mask, sequence_labels, token_labels







			def      __lowerCamelCase    (	self    ,							__UpperCAmelCase    ,							__UpperCAmelCase    ,							__UpperCAmelCase    ,							__UpperCAmelCase    ,							__UpperCAmelCase    ,							__UpperCAmelCase    ,							__UpperCAmelCase    ,							__UpperCAmelCase  ):
										SCREAMING_SNAKE_CASE_	:							Optional[int]											=LayoutLMvaModel(config=UpperCAmelCase__  )
										model.to(UpperCAmelCase__  )
										model.eval()

										# text + image
										SCREAMING_SNAKE_CASE_	:							Union[str, Any]											=model(UpperCAmelCase__    ,							pixel_values=UpperCAmelCase__  )
										SCREAMING_SNAKE_CASE_	:							Dict											=model(
										    UpperCAmelCase__    ,							bbox=UpperCAmelCase__    ,							pixel_values=UpperCAmelCase__    ,							attention_mask=UpperCAmelCase__    ,							token_type_ids=UpperCAmelCase__  )
										SCREAMING_SNAKE_CASE_	:							str											=model(UpperCAmelCase__    ,							bbox=UpperCAmelCase__    ,							pixel_values=UpperCAmelCase__    ,							token_type_ids=UpperCAmelCase__  )
										SCREAMING_SNAKE_CASE_	:							Optional[Any]											=model(UpperCAmelCase__    ,							bbox=UpperCAmelCase__    ,							pixel_values=UpperCAmelCase__  )

										self.parent.assertEqual(result.last_hidden_state.shape    ,							(self.batch_size, self.seq_length, self.hidden_size)  )

										# text only
										SCREAMING_SNAKE_CASE_	:							Dict											=model(UpperCAmelCase__  )
										self.parent.assertEqual(
										    result.last_hidden_state.shape    ,							(self.batch_size, self.text_seq_length, self.hidden_size)  )

										# image only
										SCREAMING_SNAKE_CASE_	:							Optional[int]											=model(pixel_values=UpperCAmelCase__  )
										self.parent.assertEqual(
										    result.last_hidden_state.shape    ,							(self.batch_size, self.image_seq_length, self.hidden_size)  )







			def      __lowerCamelCase    (	self    ,							__UpperCAmelCase    ,							__UpperCAmelCase    ,							__UpperCAmelCase    ,							__UpperCAmelCase    ,							__UpperCAmelCase    ,							__UpperCAmelCase    ,							__UpperCAmelCase    ,							__UpperCAmelCase  ):
										SCREAMING_SNAKE_CASE_	:							Dict											=self.num_labels
										SCREAMING_SNAKE_CASE_	:							Dict											=LayoutLMvaForSequenceClassification(UpperCAmelCase__  )
										model.to(UpperCAmelCase__  )
										model.eval()
										SCREAMING_SNAKE_CASE_	:							Dict											=model(
										    UpperCAmelCase__    ,							bbox=UpperCAmelCase__    ,							pixel_values=UpperCAmelCase__    ,							attention_mask=UpperCAmelCase__    ,							token_type_ids=UpperCAmelCase__    ,							labels=UpperCAmelCase__    ,							)
										self.parent.assertEqual(result.logits.shape    ,							(self.batch_size, self.num_labels)  )







			def      __lowerCamelCase    (	self    ,							__UpperCAmelCase    ,							__UpperCAmelCase    ,							__UpperCAmelCase    ,							__UpperCAmelCase    ,							__UpperCAmelCase    ,							__UpperCAmelCase    ,							__UpperCAmelCase    ,							__UpperCAmelCase  ):
										SCREAMING_SNAKE_CASE_	:							List[Any]											=self.num_labels
										SCREAMING_SNAKE_CASE_	:							Any											=LayoutLMvaForTokenClassification(config=UpperCAmelCase__  )
										model.to(UpperCAmelCase__  )
										model.eval()
										SCREAMING_SNAKE_CASE_	:							List[str]											=model(
										    UpperCAmelCase__    ,							bbox=UpperCAmelCase__    ,							pixel_values=UpperCAmelCase__    ,							attention_mask=UpperCAmelCase__    ,							token_type_ids=UpperCAmelCase__    ,							labels=UpperCAmelCase__    ,							)
										self.parent.assertEqual(result.logits.shape    ,							(self.batch_size, self.text_seq_length, self.num_labels)  )







			def      __lowerCamelCase    (	self    ,							__UpperCAmelCase    ,							__UpperCAmelCase    ,							__UpperCAmelCase    ,							__UpperCAmelCase    ,							__UpperCAmelCase    ,							__UpperCAmelCase    ,							__UpperCAmelCase    ,							__UpperCAmelCase  ):
										SCREAMING_SNAKE_CASE_	:							Tuple											=LayoutLMvaForQuestionAnswering(config=UpperCAmelCase__  )
										model.to(UpperCAmelCase__  )
										model.eval()
										SCREAMING_SNAKE_CASE_	:							Optional[int]											=model(
										    UpperCAmelCase__    ,							bbox=UpperCAmelCase__    ,							pixel_values=UpperCAmelCase__    ,							attention_mask=UpperCAmelCase__    ,							token_type_ids=UpperCAmelCase__    ,							start_positions=UpperCAmelCase__    ,							end_positions=UpperCAmelCase__    ,							)
										self.parent.assertEqual(result.start_logits.shape    ,							(self.batch_size, self.seq_length)  )
										self.parent.assertEqual(result.end_logits.shape    ,							(self.batch_size, self.seq_length)  )







			def      __lowerCamelCase    (	self  ):
										SCREAMING_SNAKE_CASE_	:							int											=self.prepare_config_and_inputs()
										(
										    SCREAMING_SNAKE_CASE_	
										)	:							Dict											=config_and_inputs
										SCREAMING_SNAKE_CASE_	:							List[Any]											={
										    '''input_ids''': input_ids,
										    '''bbox''': bbox,
										    '''pixel_values''': pixel_values,
										    '''token_type_ids''': token_type_ids,
										    '''attention_mask''': input_mask,
										}
										return config, inputs_dict





@require_torch
class 							lowerCAmelCase_						(    lowercase__			,		lowercase__			,		unittest.TestCase							):




			'''simple docstring'''


			_lowercase      =							False
			_lowercase      =							False
			_lowercase      =							False

			_lowercase      =							(
			    (
			        LayoutLMvaModel,
			        LayoutLMvaForSequenceClassification,
			        LayoutLMvaForTokenClassification,
			        LayoutLMvaForQuestionAnswering,
			    )
			    if is_torch_available()
			    else ()
			)
			_lowercase      =							(
			    {'document-question-answering': LayoutLMvaForQuestionAnswering, 'feature-extraction': LayoutLMvaModel}
			    if is_torch_available()
			    else {}
			)







			def      __lowerCamelCase    (	self    ,							__UpperCAmelCase    ,							__UpperCAmelCase    ,							__UpperCAmelCase    ,							__UpperCAmelCase    ,							__UpperCAmelCase  ):
										return True







			def      __lowerCamelCase    (	self  ):
										SCREAMING_SNAKE_CASE_	:							int											=LayoutLMvaModelTester(self  )
										SCREAMING_SNAKE_CASE_	:							List[Any]											=ConfigTester(self    ,							config_class=UpperCAmelCase__    ,							hidden_size=37  )







			def      __lowerCamelCase    (	self    ,							__UpperCAmelCase    ,							__UpperCAmelCase    ,							__UpperCAmelCase=False  ):
										SCREAMING_SNAKE_CASE_	:							Optional[int]											=copy.deepcopy(UpperCAmelCase__  )
										if model_class in get_values(UpperCAmelCase__  ):
																	SCREAMING_SNAKE_CASE_	:							Dict											={
																	    k: v.unsqueeze(1  ).expand(-1    ,							self.model_tester.num_choices    ,							-1  ).contiguous()
																	    if isinstance(UpperCAmelCase__    ,							torch.Tensor  ) and v.ndim > 1
																	    else v
																	    for k, v in inputs_dict.items()
																	}
										if return_labels:
																	if model_class in get_values(UpperCAmelCase__  ):
																								SCREAMING_SNAKE_CASE_	:							Union[str, Any]											=torch.ones(self.model_tester.batch_size    ,							dtype=torch.long    ,							device=UpperCAmelCase__  )
																	elif model_class in get_values(UpperCAmelCase__  ):
																								SCREAMING_SNAKE_CASE_	:							Optional[Any]											=torch.zeros(
																								    self.model_tester.batch_size    ,							dtype=torch.long    ,							device=UpperCAmelCase__  )
																								SCREAMING_SNAKE_CASE_	:							Tuple											=torch.zeros(
																								    self.model_tester.batch_size    ,							dtype=torch.long    ,							device=UpperCAmelCase__  )
																	elif model_class in [
																	    *get_values(UpperCAmelCase__  ),
																	]:
																								SCREAMING_SNAKE_CASE_	:							Dict											=torch.zeros(
																								    self.model_tester.batch_size    ,							dtype=torch.long    ,							device=UpperCAmelCase__  )
																	elif model_class in [
																	    *get_values(UpperCAmelCase__  ),
																	]:
																								SCREAMING_SNAKE_CASE_	:							Optional[Any]											=torch.zeros(
																								    (self.model_tester.batch_size, self.model_tester.text_seq_length)    ,							dtype=torch.long    ,							device=UpperCAmelCase__    ,							)

										return inputs_dict







			def      __lowerCamelCase    (	self  ):
										self.config_tester.run_common_tests()







			def      __lowerCamelCase    (	self  ):
										SCREAMING_SNAKE_CASE_	:							Any											=self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_model(*UpperCAmelCase__  )







			def      __lowerCamelCase    (	self  ):
										SCREAMING_SNAKE_CASE_	:							Dict											=self.model_tester.prepare_config_and_inputs()
										for type in ["absolute", "relative_key", "relative_key_query"]:
																	SCREAMING_SNAKE_CASE_	:							Union[str, Any]											=type
																	self.model_tester.create_and_check_model(*UpperCAmelCase__  )







			def      __lowerCamelCase    (	self  ):
										SCREAMING_SNAKE_CASE_	:							Dict											=self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_sequence_classification(*UpperCAmelCase__  )







			def      __lowerCamelCase    (	self  ):
										SCREAMING_SNAKE_CASE_	:							Any											=self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_token_classification(*UpperCAmelCase__  )







			def      __lowerCamelCase    (	self  ):
										SCREAMING_SNAKE_CASE_	:							List[Any]											=self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_question_answering(*UpperCAmelCase__  )







			@slow
			def      __lowerCamelCase    (	self  ):
										for model_name in LAYOUTLMV3_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																	SCREAMING_SNAKE_CASE_	:							Union[str, Any]											=LayoutLMvaModel.from_pretrained(UpperCAmelCase__  )
																	self.assertIsNotNone(UpperCAmelCase__  )




def    SCREAMING_SNAKE_CASE__		( )    ->   Optional[int]:







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_	:							Union[str, Any]											=Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'							)
							return image





@require_torch
class 							lowerCAmelCase_						(    unittest.TestCase							):




			'''simple docstring'''


			@cached_property
			def      __lowerCamelCase    (	self  ):
										return LayoutLMvaImageProcessor(apply_ocr=UpperCAmelCase__  ) if is_vision_available() else None







			@slow
			def      __lowerCamelCase    (	self  ):
										SCREAMING_SNAKE_CASE_	:							Optional[Any]											=LayoutLMvaModel.from_pretrained('microsoft/layoutlmv3-base'  ).to(UpperCAmelCase__  )

										SCREAMING_SNAKE_CASE_	:							Union[str, Any]											=self.default_image_processor
										SCREAMING_SNAKE_CASE_	:							str											=prepare_img()
										SCREAMING_SNAKE_CASE_	:							int											=image_processor(images=UpperCAmelCase__    ,							return_tensors='pt'  ).pixel_values.to(UpperCAmelCase__  )

										SCREAMING_SNAKE_CASE_	:							Union[str, Any]											=torch.tensor([[1, 2]]  )
										SCREAMING_SNAKE_CASE_	:							Any											=torch.tensor([[1, 2, 3, 4], [5, 6, 7, 8]]  ).unsqueeze(0  )

										# forward pass
										SCREAMING_SNAKE_CASE_	:							Tuple											=model(
										    input_ids=input_ids.to(UpperCAmelCase__  )    ,							bbox=bbox.to(UpperCAmelCase__  )    ,							pixel_values=pixel_values.to(UpperCAmelCase__  )    ,							)

										# verify the logits
										SCREAMING_SNAKE_CASE_	:							str											=torch.Size((1, 199, 768)  )
										self.assertEqual(outputs.last_hidden_state.shape    ,							UpperCAmelCase__  )

										SCREAMING_SNAKE_CASE_	:							Optional[int]											=torch.tensor(
										    [[-0.0_529, 0.3_618, 0.1_632], [-0.1_587, -0.1_667, -0.0_400], [-0.1_557, -0.1_671, -0.0_505]]  ).to(UpperCAmelCase__  )

										self.assertTrue(torch.allclose(outputs.last_hidden_state[0, :3, :3]    ,							UpperCAmelCase__    ,							atol=1E-4  )  )








'''simple docstring'''





from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_sentencepiece_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


UpperCamelCase_    						=       {"""configuration_mbart""": ["""MBART_PRETRAINED_CONFIG_ARCHIVE_MAP""", """MBartConfig""", """MBartOnnxConfig"""]}

try:
							if not is_sentencepiece_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							UpperCamelCase_    						=       ["""MBartTokenizer"""]

try:
							if not is_tokenizers_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							UpperCamelCase_    						=       ["""MBartTokenizerFast"""]

try:
							if not is_torch_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							UpperCamelCase_    						=       [
							    """MBART_PRETRAINED_MODEL_ARCHIVE_LIST""",
							    """MBartForCausalLM""",
							    """MBartForConditionalGeneration""",
							    """MBartForQuestionAnswering""",
							    """MBartForSequenceClassification""",
							    """MBartModel""",
							    """MBartPreTrainedModel""",
							]

try:
							if not is_tf_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							UpperCamelCase_    						=       [
							    """TFMBartForConditionalGeneration""",
							    """TFMBartModel""",
							    """TFMBartPreTrainedModel""",
							]

try:
							if not is_flax_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							UpperCamelCase_    						=       [
							    """FlaxMBartForConditionalGeneration""",
							    """FlaxMBartForQuestionAnswering""",
							    """FlaxMBartForSequenceClassification""",
							    """FlaxMBartModel""",
							    """FlaxMBartPreTrainedModel""",
							]


if TYPE_CHECKING:
							from .configuration_mbart import MBART_PRETRAINED_CONFIG_ARCHIVE_MAP, MBartConfig, MBartOnnxConfig

							try:
														if not is_sentencepiece_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .tokenization_mbart import MBartTokenizer

							try:
														if not is_tokenizers_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .tokenization_mbart_fast import MBartTokenizerFast

							try:
														if not is_torch_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_mbart import (
														    MBART_PRETRAINED_MODEL_ARCHIVE_LIST,
														    MBartForCausalLM,
														    MBartForConditionalGeneration,
														    MBartForQuestionAnswering,
														    MBartForSequenceClassification,
														    MBartModel,
														    MBartPreTrainedModel,
														)

							try:
														if not is_tf_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_tf_mbart import TFMBartForConditionalGeneration, TFMBartModel, TFMBartPreTrainedModel

							try:
														if not is_flax_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_flax_mbart import (
														    FlaxMBartForConditionalGeneration,
														    FlaxMBartForQuestionAnswering,
														    FlaxMBartForSequenceClassification,
														    FlaxMBartModel,
														    FlaxMBartPreTrainedModel,
														)

else:
							import sys

							UpperCamelCase_    						=       _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)





